text string | size int64 | token_count int64 |
|---|---|---|
#include "RenderSystem/Vulkan/Vulkan.h"
#include "Core/Platform/CPlatform.h"
#include "Core/Utils/CLogger.h"
//#undef VKE_VK_FUNCTION
//#define VKE_VK_FUNCTION(_name) PFN_##_name _name
//#undef VK_EXPORTED_FUNCTION
//#undef VKE_ICD_GLOBAL
//#undef VKE_INSTANCE_ICD
//#undef VKE_DEVICE_ICD
//#define VK_EXPORTED_FUNCTION(name) PFN_##name name = 0
//#define VKE_ICD_GLOBAL(name) PFN_##name name = 0
//#define VKE_INSTANCE_ICD(name) PFN_##name name = 0
//#define VKE_DEVICE_ICD(name) PFN_##name name = 0
//#include "ThirdParty/vulkan/funclist.h"
//#undef VKE_DEVICE_ICD
//#undef VKE_INSTANCE_ICD
//#undef VKE_ICD_GLOBAL
//#undef VK_EXPORTED_FUNCTION
//#undef VKE_VK_FUNCTION
namespace VKE
{
namespace Vulkan
{
using ErrorMap = std::map< std::thread::id, VkResult >;
ErrorMap g_mErrors;
std::mutex g_ErrorMutex;
void SetLastError( VkResult err )
{
g_ErrorMutex.lock();
g_mErrors[ std::this_thread::get_id() ] = err;
g_ErrorMutex.unlock();
}
VkResult GetLastError()
{
g_ErrorMutex.lock();
auto ret = g_mErrors[ std::this_thread::get_id() ];
g_ErrorMutex.unlock();
return ret;
}
SQueue::SQueue()
{
this->m_objRefCount = 0;
Vulkan::InitInfo( &m_PresentInfo, VK_STRUCTURE_TYPE_PRESENT_INFO_KHR );
m_PresentInfo.pResults = nullptr;
}
VkResult SQueue::Submit( const VkICD::Device& ICD, const VkSubmitInfo& Info, const VkFence& vkFence )
{
Lock();
auto res = ICD.vkQueueSubmit( vkQueue, 1, &Info, vkFence );
Unlock();
return res;
}
bool SQueue::IsPresentDone()
{
return m_isPresentDone;
}
void SQueue::ReleasePresentNotify()
{
Lock();
if( m_presentCount-- < 0 )
m_presentCount = 0;
m_isPresentDone = m_presentCount == 0;
Unlock();
}
void SQueue::Wait( const VkICD::Device& ICD )
{
ICD.vkQueueWaitIdle( vkQueue );
}
Result SQueue::Present( const VkICD::Device& ICD, uint32_t imgIdx, VkSwapchainKHR vkSwpChain,
VkSemaphore vkWaitSemaphore )
{
Result res = VKE_ENOTREADY;
Lock();
m_PresentData.vImageIndices.PushBack( imgIdx );
m_PresentData.vSwapChains.PushBack( vkSwpChain );
m_PresentData.vWaitSemaphores.PushBack( vkWaitSemaphore );
m_presentCount++;
m_isPresentDone = false;
if( this->GetRefCount() == m_PresentData.vSwapChains.GetCount() )
{
m_PresentInfo.pImageIndices = &m_PresentData.vImageIndices[ 0 ];
m_PresentInfo.pSwapchains = &m_PresentData.vSwapChains[ 0 ];
m_PresentInfo.pWaitSemaphores = &m_PresentData.vWaitSemaphores[ 0 ];
m_PresentInfo.swapchainCount = m_PresentData.vSwapChains.GetCount();
m_PresentInfo.waitSemaphoreCount = m_PresentData.vWaitSemaphores.GetCount();
VK_ERR( ICD.vkQueuePresentKHR( vkQueue, &m_PresentInfo ) );
// $TID Present: q={vkQueue}, sc={m_PresentInfo.pSwapchains[0]}, imgIdx={m_PresentInfo.pImageIndices[0]}, ws={m_PresentInfo.pWaitSemaphores[0]}
m_isPresentDone = true;
m_PresentData.vImageIndices.Clear();
m_PresentData.vSwapChains.Clear();
m_PresentData.vWaitSemaphores.Clear();
res = VKE_OK;
}
Unlock();
return res;
}
bool IsColorImage( VkFormat format )
{
switch( format )
{
case VK_FORMAT_UNDEFINED:
case VK_FORMAT_D16_UNORM:
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_S8_UINT:
return false;
}
return true;
}
bool IsDepthImage( VkFormat format )
{
switch( format )
{
case VK_FORMAT_D16_UNORM:
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_S8_UINT:
return true;
}
return false;
}
bool IsStencilImage( VkFormat format )
{
switch( format )
{
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_S8_UINT:
return true;
}
return false;
}
namespace Map
{
VkImageType ImageType( RenderSystem::TEXTURE_TYPE type )
{
static const VkImageType aVkImageTypes[] =
{
VK_IMAGE_TYPE_1D,
VK_IMAGE_TYPE_2D,
VK_IMAGE_TYPE_3D,
VK_IMAGE_TYPE_2D, // cube
};
return aVkImageTypes[ type ];
}
VkImageViewType ImageViewType( RenderSystem::TEXTURE_VIEW_TYPE type )
{
static const VkImageViewType aVkTypes[] =
{
VK_IMAGE_VIEW_TYPE_1D,
VK_IMAGE_VIEW_TYPE_2D,
VK_IMAGE_VIEW_TYPE_3D,
VK_IMAGE_VIEW_TYPE_1D_ARRAY,
VK_IMAGE_VIEW_TYPE_2D_ARRAY,
VK_IMAGE_VIEW_TYPE_CUBE,
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
};
return aVkTypes[ type ];
}
VkImageUsageFlags ImageUsage( RenderSystem::TEXTURE_USAGE usage )
{
/*static const VkImageUsageFlags aVkUsages[] =
{
VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
VK_IMAGE_USAGE_TRANSFER_DST_BIT,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
VK_IMAGE_USAGE_SAMPLED_BIT,
VK_IMAGE_USAGE_STORAGE_BIT,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
};
return aVkUsages[ usage ];*/
using namespace RenderSystem;
VkImageUsageFlags flags = 0;
if( usage & TextureUsages::SAMPLED )
{
flags |= VK_IMAGE_USAGE_SAMPLED_BIT;
}
if( usage & TextureUsages::COLOR_RENDER_TARGET )
{
flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
}
else if( usage & TextureUsages::DEPTH_STENCIL_RENDER_TARGET )
{
flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
}
if( usage & TextureUsages::STORAGE )
{
flags |= VK_IMAGE_USAGE_STORAGE_BIT;
}
if( usage & TextureUsages::TRANSFER_DST )
{
flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
}
if( usage & TextureUsages::TRANSFER_SRC )
{
flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
}
return flags;
}
VkImageLayout ImageLayout( RenderSystem::TEXTURE_STATE layout )
{
static const VkImageLayout aVkLayouts[] =
{
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
};
return aVkLayouts[ layout ];
}
VkImageAspectFlags ImageAspect( RenderSystem::TEXTURE_ASPECT aspect )
{
static const VkImageAspectFlags aVkAspects[] =
{
// UNKNOWN
0,
// COLOR
VK_IMAGE_ASPECT_COLOR_BIT,
// DEPTH
VK_IMAGE_ASPECT_DEPTH_BIT,
// STENCIL
VK_IMAGE_ASPECT_STENCIL_BIT,
// DEPTH_STENCIL
VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT
};
return aVkAspects[ aspect ];
}
VkMemoryPropertyFlags MemoryPropertyFlags( RenderSystem::MEMORY_USAGE usages )
{
using namespace RenderSystem;
VkMemoryPropertyFlags flags = 0;
if( usages & MemoryUsages::CPU_ACCESS )
{
flags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
}
if( usages & MemoryUsages::CPU_CACHED )
{
flags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
}
if( usages & MemoryUsages::CPU_NO_FLUSH )
{
flags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
}
if( usages & MemoryUsages::GPU_ACCESS )
{
flags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
}
return flags;
}
VkBlendOp BlendOp( const RenderSystem::BLEND_OPERATION& op )
{
static const VkBlendOp aVkOps[] =
{
VK_BLEND_OP_ADD,
VK_BLEND_OP_SUBTRACT,
VK_BLEND_OP_REVERSE_SUBTRACT,
VK_BLEND_OP_MIN,
VK_BLEND_OP_MAX
};
return aVkOps[ op ];
}
VkColorComponentFlags ColorComponent( const RenderSystem::ColorComponent& component )
{
VkColorComponentFlags vkComponent = 0;
if( component & RenderSystem::ColorComponents::ALL )
{
vkComponent = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
}
else
{
if( component & RenderSystem::ColorComponents::ALPHA )
{
vkComponent |= VK_COLOR_COMPONENT_A_BIT;
}
if( component & RenderSystem::ColorComponents::BLUE )
{
vkComponent |= VK_COLOR_COMPONENT_B_BIT;
}
if( component & RenderSystem::ColorComponents::GREEN )
{
vkComponent |= VK_COLOR_COMPONENT_G_BIT;
}
if( component & RenderSystem::ColorComponents::RED )
{
vkComponent |= VK_COLOR_COMPONENT_R_BIT;
}
}
return vkComponent;
}
VkBlendFactor BlendFactor( const RenderSystem::BLEND_FACTOR& factor )
{
static const VkBlendFactor aVkFactors[] =
{
VK_BLEND_FACTOR_ZERO,
VK_BLEND_FACTOR_ONE,
VK_BLEND_FACTOR_SRC_COLOR,
VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
VK_BLEND_FACTOR_DST_COLOR,
VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
VK_BLEND_FACTOR_SRC_ALPHA,
VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
VK_BLEND_FACTOR_DST_ALPHA,
VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
VK_BLEND_FACTOR_CONSTANT_COLOR,
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
VK_BLEND_FACTOR_CONSTANT_ALPHA,
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
VK_BLEND_FACTOR_SRC1_COLOR,
VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
VK_BLEND_FACTOR_SRC1_ALPHA,
VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
};
return aVkFactors[ factor ];
}
VkLogicOp LogicOperation( const RenderSystem::LOGIC_OPERATION& op )
{
static const VkLogicOp aVkOps[] =
{
VK_LOGIC_OP_CLEAR,
VK_LOGIC_OP_AND,
VK_LOGIC_OP_AND_REVERSE,
VK_LOGIC_OP_COPY,
VK_LOGIC_OP_AND_INVERTED,
VK_LOGIC_OP_NO_OP,
VK_LOGIC_OP_XOR,
VK_LOGIC_OP_OR,
VK_LOGIC_OP_NOR,
VK_LOGIC_OP_EQUIVALENT,
VK_LOGIC_OP_INVERT,
VK_LOGIC_OP_OR_REVERSE,
VK_LOGIC_OP_COPY_INVERTED,
VK_LOGIC_OP_OR_INVERTED,
VK_LOGIC_OP_NAND,
VK_LOGIC_OP_SET
};
return aVkOps[ op ];
}
VkStencilOp StencilOperation( const RenderSystem::STENCIL_FUNCTION& op )
{
static const VkStencilOp aVkOps[] =
{
VK_STENCIL_OP_KEEP,
VK_STENCIL_OP_ZERO,
VK_STENCIL_OP_REPLACE,
VK_STENCIL_OP_INCREMENT_AND_CLAMP,
VK_STENCIL_OP_DECREMENT_AND_CLAMP,
VK_STENCIL_OP_INVERT,
VK_STENCIL_OP_INCREMENT_AND_WRAP,
VK_STENCIL_OP_DECREMENT_AND_WRAP
};
return aVkOps[ op ];
}
VkCompareOp CompareOperation( const RenderSystem::COMPARE_FUNCTION& op )
{
static const VkCompareOp aVkOps[] =
{
VK_COMPARE_OP_NEVER,
VK_COMPARE_OP_LESS,
VK_COMPARE_OP_EQUAL,
VK_COMPARE_OP_LESS_OR_EQUAL,
VK_COMPARE_OP_GREATER,
VK_COMPARE_OP_NOT_EQUAL,
VK_COMPARE_OP_GREATER_OR_EQUAL,
VK_COMPARE_OP_ALWAYS
};
return aVkOps[ op ];
}
VkPrimitiveTopology PrimitiveTopology(const RenderSystem::PRIMITIVE_TOPOLOGY& topology)
{
static const VkPrimitiveTopology aVkTopologies[] =
{
VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
};
return aVkTopologies[ topology ];
}
VkSampleCountFlagBits SampleCount(const RenderSystem::SAMPLE_COUNT& count)
{
static const VkSampleCountFlagBits aVkSamples[] =
{
VK_SAMPLE_COUNT_1_BIT,
VK_SAMPLE_COUNT_2_BIT,
VK_SAMPLE_COUNT_4_BIT,
VK_SAMPLE_COUNT_8_BIT,
VK_SAMPLE_COUNT_16_BIT,
VK_SAMPLE_COUNT_32_BIT,
VK_SAMPLE_COUNT_64_BIT
};
return aVkSamples[ count ];
}
VkCullModeFlags CullMode( const RenderSystem::CULL_MODE& mode )
{
static const VkCullModeFlagBits aVkModes[] =
{
VK_CULL_MODE_NONE,
VK_CULL_MODE_FRONT_BIT,
VK_CULL_MODE_BACK_BIT,
VK_CULL_MODE_FRONT_AND_BACK
};
return aVkModes[ mode ];
}
VkFrontFace FrontFace( const RenderSystem::FRONT_FACE& face )
{
static const VkFrontFace aVkFaces[] =
{
VK_FRONT_FACE_COUNTER_CLOCKWISE,
VK_FRONT_FACE_CLOCKWISE
};
return aVkFaces[ face ];
}
VkPolygonMode PolygonMode( const RenderSystem::POLYGON_MODE& mode )
{
static const VkPolygonMode aVkModes[] =
{
VK_POLYGON_MODE_FILL,
VK_POLYGON_MODE_LINE,
VK_POLYGON_MODE_POINT
};
return aVkModes[ mode ];
}
VkShaderStageFlagBits ShaderStage( const RenderSystem::SHADER_TYPE& type )
{
static const VkShaderStageFlagBits aVkBits[] =
{
VK_SHADER_STAGE_VERTEX_BIT,
VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
VK_SHADER_STAGE_GEOMETRY_BIT,
VK_SHADER_STAGE_FRAGMENT_BIT,
VK_SHADER_STAGE_COMPUTE_BIT
};
return aVkBits[ type ];
}
VkVertexInputRate InputRate( const RenderSystem::VERTEX_INPUT_RATE& rate )
{
static const VkVertexInputRate aVkRates[] =
{
VK_VERTEX_INPUT_RATE_VERTEX,
VK_VERTEX_INPUT_RATE_INSTANCE
};
return aVkRates[ rate ];
}
VkDescriptorType DescriptorType(const RenderSystem::DESCRIPTOR_SET_TYPE& type)
{
static const VkDescriptorType aVkDescriptorType[] =
{
VK_DESCRIPTOR_TYPE_SAMPLER,
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
};
return aVkDescriptorType[ type ];
}
} // Map
namespace Convert
{
VkImageAspectFlags UsageToAspectMask( VkImageUsageFlags usage )
{
if( usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT )
{
return VK_IMAGE_ASPECT_COLOR_BIT;
}
if( usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT )
{
return VK_IMAGE_ASPECT_DEPTH_BIT;
}
VKE_LOG_ERR( "Invalid image usage: " << usage << " to use for aspectMask" );
assert( 0 && "Invalid image usage" );
return VK_IMAGE_ASPECT_COLOR_BIT;
}
VkImageViewType ImageTypeToViewType( VkImageType type )
{
static const VkImageViewType aTypes[] =
{
VK_IMAGE_VIEW_TYPE_1D,
VK_IMAGE_VIEW_TYPE_2D,
VK_IMAGE_VIEW_TYPE_3D
};
assert( type <= VK_IMAGE_TYPE_3D && "Invalid image type for image view type" );
return aTypes[ type ];
}
VkAttachmentLoadOp UsageToLoadOp( RenderSystem::RENDER_PASS_ATTACHMENT_USAGE usage )
{
static const VkAttachmentLoadOp aLoads[] =
{
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // undefined
VK_ATTACHMENT_LOAD_OP_LOAD, // color
VK_ATTACHMENT_LOAD_OP_CLEAR, // color clear
VK_ATTACHMENT_LOAD_OP_LOAD, // color store
VK_ATTACHMENT_LOAD_OP_CLEAR, // color clear store
VK_ATTACHMENT_LOAD_OP_LOAD, // depth
VK_ATTACHMENT_LOAD_OP_CLEAR, // depth clear
VK_ATTACHMENT_LOAD_OP_LOAD, // depth store
VK_ATTACHMENT_LOAD_OP_CLEAR, // depth clear store
};
return aLoads[ usage ];
}
VkAttachmentStoreOp UsageToStoreOp( RenderSystem::RENDER_PASS_ATTACHMENT_USAGE usage )
{
static const VkAttachmentStoreOp aStores[] =
{
VK_ATTACHMENT_STORE_OP_STORE, // undefined
VK_ATTACHMENT_STORE_OP_STORE, // color
VK_ATTACHMENT_STORE_OP_STORE, // color clear
VK_ATTACHMENT_STORE_OP_STORE, // color store
VK_ATTACHMENT_STORE_OP_STORE, // color clear store
VK_ATTACHMENT_STORE_OP_STORE, // depth
VK_ATTACHMENT_STORE_OP_STORE, // depth clear
VK_ATTACHMENT_STORE_OP_STORE, // depth store
VK_ATTACHMENT_STORE_OP_STORE, // depth clear store
};
return aStores[ usage ];
}
VkImageLayout ImageUsageToLayout( VkImageUsageFlags vkFlags )
{
const auto imgSampled = vkFlags & VK_IMAGE_USAGE_SAMPLED_BIT;
const auto inputAttachment = vkFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
const auto isReadOnly = imgSampled || inputAttachment;
if( vkFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT )
{
return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
else if( vkFlags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT )
{
if( isReadOnly )
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
}
else if( vkFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT )
{
return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
}
else if( vkFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT )
{
return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
}
else if( isReadOnly )
{
return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
}
assert( 0 && "Invalid image usage flags" );
VKE_LOG_ERR( "Usage flags: " << vkFlags << " are invalid." );
return VK_IMAGE_LAYOUT_UNDEFINED;
}
VkImageLayout ImageUsageToInitialLayout( VkImageUsageFlags vkFlags )
{
if( vkFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT )
{
return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
else if( vkFlags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT )
{
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
}
assert( 0 && "Invalid image usage flags" );
VKE_LOG_ERR( "Usage flags: " << vkFlags << " are invalid." );
return VK_IMAGE_LAYOUT_UNDEFINED;
}
VkImageLayout ImageUsageToFinalLayout( VkImageUsageFlags vkFlags )
{
const auto imgSampled = vkFlags & VK_IMAGE_USAGE_SAMPLED_BIT;
const auto inputAttachment = vkFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
bool isReadOnly = imgSampled || inputAttachment;
if( vkFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT )
{
if( isReadOnly )
return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
else if( vkFlags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT )
{
if( isReadOnly )
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
}
assert( 0 && "Invalid image usage flags" );
VKE_LOG_ERR( "Usage flags: " << vkFlags << " are invalid." );
return VK_IMAGE_LAYOUT_UNDEFINED;
}
VkImageLayout NextAttachmentLayoutRread( VkImageLayout currLayout )
{
if( currLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL )
{
return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
}
if( currLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL )
{
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
}
assert( 0 && "Incorrect initial layout for attachment." );
return VK_IMAGE_LAYOUT_UNDEFINED;
}
VkImageLayout NextAttachmentLayoutOptimal( VkImageLayout currLayout )
{
if( currLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL )
{
return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
if( currLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL )
{
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
}
assert( 0 && "Incorrect initial layout for attachment." );
return VK_IMAGE_LAYOUT_UNDEFINED;
}
RenderSystem::TEXTURE_FORMAT ImageFormat( VkFormat vkFormat )
{
switch( vkFormat )
{
case VK_FORMAT_B8G8R8A8_UNORM: return RenderSystem::Formats::B8G8R8A8_UNORM;
};
assert( 0 && "Cannot convert VkFormat to RenderSystem format" );
return RenderSystem::Formats::UNDEFINED;
}
VkPipelineStageFlags PipelineStages(const RenderSystem::PIPELINE_STAGES& stages)
{
VkPipelineStageFlags vkFlags = 0;
if( stages & RenderSystem::PipelineStages::COMPUTE )
{
vkFlags |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
}
if( stages & RenderSystem::PipelineStages::GEOMETRY )
{
vkFlags |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
}
if( stages & RenderSystem::PipelineStages::PIXEL )
{
vkFlags |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
}
if( stages & RenderSystem::PipelineStages::TS_DOMAIN )
{
vkFlags |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
}
if( stages & RenderSystem::PipelineStages::TS_HULL )
{
vkFlags |= VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
}
if( stages & RenderSystem::PipelineStages::VERTEX )
{
vkFlags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
}
return vkFlags;
}
VkBufferUsageFlags BufferUsage( const RenderSystem::BUFFER_USAGE& usage )
{
VkBufferUsageFlags vkFlags = 0;
if( usage & RenderSystem::BufferUsages::INDEX_BUFFER )
{
vkFlags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
}
if( usage & RenderSystem::BufferUsages::VERTEX_BUFFER )
{
vkFlags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
}
if( usage & RenderSystem::BufferUsages::CONSTANT_BUFFER )
{
vkFlags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
}
if( usage & RenderSystem::BufferUsages::TRANSFER_DST )
{
vkFlags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
}
if( usage & RenderSystem::BufferUsages::TRANSFER_SRC )
{
vkFlags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
}
if( usage & RenderSystem::BufferUsages::INDIRECT_BUFFER )
{
vkFlags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
}
if( usage & RenderSystem::BufferUsages::STORAGE_BUFFER )
{
vkFlags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
}
if( usage & RenderSystem::BufferUsages::STORAGE_TEXEL_BUFFER )
{
vkFlags |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
}
if( usage & RenderSystem::BufferUsages::UNIFORM_TEXEL_BUFFER )
{
vkFlags |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
}
return vkFlags;
}
VkImageTiling ImageUsageToTiling( const RenderSystem::TEXTURE_USAGE& usage )
{
VkImageTiling vkTiling = VK_IMAGE_TILING_OPTIMAL;
if( usage & RenderSystem::TextureUsages::FILE_IO )
{
vkTiling = VK_IMAGE_TILING_LINEAR;
}
return vkTiling;
}
static const VkMemoryPropertyFlags g_aRequiredMemoryFlags[] =
{
0, // unknown
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, // gpu
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, // cpu access
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT // cpu access optimal
};
VkMemoryPropertyFlags MemoryUsagesToVkMemoryPropertyFlags( const RenderSystem::MEMORY_USAGE& usages )
{
VkMemoryPropertyFlags flags = 0;
if( usages & RenderSystem::MemoryUsages::GPU_ACCESS )
{
flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
}
else
{
if( usages & RenderSystem::MemoryUsages::CPU_ACCESS )
{
flags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
}
if( usages & RenderSystem::MemoryUsages::CPU_NO_FLUSH )
{
flags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
}
if( usages & RenderSystem::MemoryUsages::CPU_CACHED )
{
flags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
}
}
return flags;
}
} // Convert
#define VKE_EXPORT_FUNC(_name, _handle, _getProcAddr) \
pOut->_name = (PFN_##_name)(_getProcAddr((_handle), #_name)); \
if(!pOut->_name) \
{ VKE_LOG_ERR("Unable to load function: " << #_name); err = VKE_ENOTFOUND; }
#define VKE_EXPORT_EXT_FUNC(_name, _handle, _getProcAddr) \
pOut->_name = (PFN_##_name)(_getProcAddr((_handle), #_name)); \
if(!pOut->_name) \
{ VKE_LOG_ERR("Unable to load function: " << #_name); }
Result LoadGlobalFunctions( handle_t hLib, VkICD::Global* pOut )
{
Result err = VKE_OK;
#if VKE_AUTO_ICD
#define VK_EXPORTED_FUNCTION(_name) VKE_EXPORT_FUNC(_name, hLib, Platform::DynamicLibrary::GetProcAddress)
#include "ThirdParty/vulkan/VKEICD.h"
#undef VK_EXPORTED_FUNCTION
#define VKE_ICD_GLOBAL(_name) VKE_EXPORT_FUNC(_name, VK_NULL_HANDLE, pOut->vkGetInstanceProcAddr)
#include "ThirdParty/vulkan/VKEICD.h"
#undef VKE_ICD_GLOBAL
#else // VKE_AUTO_ICD
pOut->vkGetInstanceProcAddr = reinterpret_cast< PFN_vkGetInstanceProcAddr >( Platform::GetProcAddress( hLib, "vkGetInstanceProcAddr" ) );
pOut->vkCreateInstance = reinterpret_cast< PFN_vkCreateInstance >( pOut->vkGetInstanceProcAddr( VK_NULL_HANDLE, "vkCreateInstance" ) );
//pOut->vkDestroyInstance = reinterpret_cast< PFN_vkDestroyInstance >( pOut->vkGetInstanceProcAddr( VK_NULL_HANDLE, "vkDestroyInstance" ) );
pOut->vkEnumerateInstanceExtensionProperties = reinterpret_cast< PFN_vkEnumerateInstanceExtensionProperties >( pOut->vkGetInstanceProcAddr( VK_NULL_HANDLE, "vkEnumerateInstanceExtensionProperties" ) );
pOut->vkEnumerateInstanceLayerProperties = reinterpret_cast< PFN_vkEnumerateInstanceLayerProperties >( pOut->vkGetInstanceProcAddr( VK_NULL_HANDLE, "vkEnumerateInstanceLayerProperties" ) );
#endif // VKE_AUTO_ICD
return err;
}
Result LoadInstanceFunctions( VkInstance vkInstance, const VkICD::Global& Global,
VkICD::Instance* pOut )
{
Result err = VKE_OK;
#if VKE_AUTO_ICD
# undef VKE_INSTANCE_ICD
# undef VKE_INSTANCE_EXT_ICD
# define VKE_INSTANCE_ICD(_name) VKE_EXPORT_FUNC(_name, vkInstance, Global.vkGetInstanceProcAddr)
# define VKE_INSTANCE_EXT_ICD(_name) VKE_EXPORT_EXT_FUNC(_name, vkInstance, Global.vkGetInstanceProcAddr)
# include "ThirdParty/vulkan/VKEICD.h"
# undef VKE_INSTANCE_ICD
# undef VKE_INSTANCE_EXT_ICD
#else // VKE_AUTO_ICD
pOut->vkDestroySurfaceKHR = reinterpret_cast< PFN_vkDestroySurfaceKHR >( Global.vkGetInstanceProcAddr( vkInstance, "vkDestroySurfaceKHR" ) );
#endif // VKE_AUTO_ICD
return err;
}
Result LoadDeviceFunctions( VkDevice vkDevice, const VkICD::Instance& Instance, VkICD::Device* pOut )
{
Result err = VKE_OK;
#if VKE_AUTO_ICD
# undef VKE_DEVICE_ICD
# undef VKE_DEVICE_EXT_ICD
# define VKE_DEVICE_ICD(_name) VKE_EXPORT_FUNC(_name, vkDevice, Instance.vkGetDeviceProcAddr)
# define VKE_DEVICE_EXT_ICD(_name) VKE_EXPORT_EXT_FUNC(_name, vkDevice, Instance.vkGetDeviceProcAddr);
# include "ThirdParty/vulkan/VKEICD.h"
# undef VKE_DEVICE_ICD
# undef VKE_DEVICE_EXT_ICD
#else // VKE_AUTO_ICD
#endif // VKE_AUTO_ICD
return err;
}
}
} | 35,778 | 11,805 |
/******************************************************************************
* Copyright (C) 2015 by Ralf Kaestner *
* ralf.kaestner@gmail.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the Lesser GNU General Public License as published by*
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* Lesser GNU General Public License for more details. *
* *
* You should have received a copy of the Lesser GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
******************************************************************************/
#include "rqt_multiplot/CurveDataVector.h"
namespace rqt_multiplot {
/*****************************************************************************/
/* Constructors and Destructor */
/*****************************************************************************/
CurveDataVector::CurveDataVector() {
}
CurveDataVector::~CurveDataVector() {
}
/*****************************************************************************/
/* Accessors */
/*****************************************************************************/
size_t CurveDataVector::getNumPoints() const {
return points_.count();
}
QPointF CurveDataVector::getPoint(size_t index) const {
return points_[index];
}
QVector<size_t> CurveDataVector::getPointsInDistance(double x, double
maxDistance) const {
QVector<size_t> indexes;
XCoordinateRefSet::const_iterator it = x_.lower_bound(x-maxDistance);
while (it != x_.end()) {
if (fabs(x-it->x_) <= maxDistance) {
indexes.push_back(it->index_);
++it;
}
else
break;
}
return indexes;
}
BoundingRectangle CurveDataVector::getBounds() const {
return bounds_;
}
/*****************************************************************************/
/* Methods */
/*****************************************************************************/
void CurveDataVector::appendPoint(const QPointF& point) {
bounds_ += point;
if (points_.capacity() < points_.count()+1)
points_.reserve(points_.capacity() ? 2*points_.capacity() : 1);
points_.append(point);
if (x_.capacity() < x_.size()+1)
x_.reserve(x_.capacity() ? 2*x_.capacity() : 1);
x_.insert(XCoordinateRef(point.x(), points_.size()-1));
}
void CurveDataVector::clearPoints() {
points_.clear();
x_.clear();
bounds_.clear();
}
}
| 3,330 | 835 |
/*coderanant*/
#define ll long long
#define f1(i,a,b) for(int i=a;i<b;i++)
#define f2(i,a,b) for(int i=a;i>=b;i--)
#define endl '\n'
#define pb push_back
#define gp " "
#define ff first
#define ss second
#define mp make_pair
const int mod=1000000007;
ll temp;
class Solution {
public:
int repeatedNTimes(vector<int>& A)
{
int n = A.size();
f1(i,0,n)
{
f1(j,max(i-3,0),i)
{
if(A[i]==A[j])
return A[i];
}
}
return 0;
}
}; | 539 | 231 |
#include <limits>
#include "catch.hpp"
#include "data_types.h"
#include "hdf5_particle.h"
#include "material/material.h"
#include "mpi_datatypes.h"
#include "particle.h"
#ifdef USE_MPI
//! \brief Check particle class for 1D case
TEST_CASE("MPI HDF5 Particle is checked", "[particle][mpi][hdf5]") {
// Dimension
const unsigned Dim = 3;
// Tolerance
const double Tolerance = 1.E-7;
// Check MPI transfer of HDF5 Particle
SECTION("MPI HDF5 Particle") {
mpm::Index id = 0;
mpm::HDF5Particle h5_particle;
h5_particle.id = 13;
h5_particle.mass = 501.5;
h5_particle.pressure = 125.75;
Eigen::Vector3d coords;
coords << 1., 2., 3.;
h5_particle.coord_x = coords[0];
h5_particle.coord_y = coords[1];
h5_particle.coord_z = coords[2];
Eigen::Vector3d displacement;
displacement << 0.01, 0.02, 0.03;
h5_particle.displacement_x = displacement[0];
h5_particle.displacement_y = displacement[1];
h5_particle.displacement_z = displacement[2];
Eigen::Vector3d lsize;
lsize << 0.25, 0.5, 0.75;
h5_particle.nsize_x = lsize[0];
h5_particle.nsize_y = lsize[1];
h5_particle.nsize_z = lsize[2];
Eigen::Vector3d velocity;
velocity << 1.5, 2.5, 3.5;
h5_particle.velocity_x = velocity[0];
h5_particle.velocity_y = velocity[1];
h5_particle.velocity_z = velocity[2];
Eigen::Matrix<double, 6, 1> stress;
stress << 11.5, -12.5, 13.5, 14.5, -15.5, 16.5;
h5_particle.stress_xx = stress[0];
h5_particle.stress_yy = stress[1];
h5_particle.stress_zz = stress[2];
h5_particle.tau_xy = stress[3];
h5_particle.tau_yz = stress[4];
h5_particle.tau_xz = stress[5];
Eigen::Matrix<double, 6, 1> strain;
strain << 0.115, -0.125, 0.135, 0.145, -0.155, 0.165;
h5_particle.strain_xx = strain[0];
h5_particle.strain_yy = strain[1];
h5_particle.strain_zz = strain[2];
h5_particle.gamma_xy = strain[3];
h5_particle.gamma_yz = strain[4];
h5_particle.gamma_xz = strain[5];
h5_particle.epsilon_v = strain.head(Dim).sum();
h5_particle.status = true;
h5_particle.cell_id = 1;
h5_particle.volume = 2.;
h5_particle.material_id = 1;
h5_particle.nstate_vars = 0;
for (unsigned i = 0; i < h5_particle.nstate_vars; ++i)
h5_particle.svars[i] = 0.;
// Check send and receive particle with HDF5
SECTION("Check send and receive particle with HDF5") {
// Get number of MPI ranks
int mpi_size;
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
// If on same rank
int sender = 0;
int receiver = 0;
// Get rank and do the corresponding job for mpi size == 2
if (mpi_size == 2) receiver = 1;
int mpi_rank;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
// Send particle
if (mpi_rank == sender) {
// Initialize MPI datatypes
MPI_Datatype particle_type =
mpm::register_mpi_particle_type(h5_particle);
MPI_Send(&h5_particle, 1, particle_type, receiver, 0, MPI_COMM_WORLD);
mpm::deregister_mpi_particle_type(particle_type);
}
// Receive particle
if (mpi_rank == receiver) {
// Receive the messid
struct mpm::HDF5Particle received;
MPI_Datatype particle_type = mpm::register_mpi_particle_type(received);
MPI_Recv(&received, 1, particle_type, sender, 0, MPI_COMM_WORLD,
MPI_STATUS_IGNORE);
mpm::deregister_mpi_particle_type(particle_type);
REQUIRE(h5_particle.id == received.id);
REQUIRE(h5_particle.mass == received.mass);
REQUIRE(h5_particle.pressure ==
Approx(received.pressure).epsilon(Tolerance));
REQUIRE(h5_particle.volume ==
Approx(received.volume).epsilon(Tolerance));
REQUIRE(h5_particle.coord_x ==
Approx(received.coord_x).epsilon(Tolerance));
REQUIRE(h5_particle.coord_y ==
Approx(received.coord_y).epsilon(Tolerance));
REQUIRE(h5_particle.coord_z ==
Approx(received.coord_z).epsilon(Tolerance));
REQUIRE(h5_particle.displacement_x ==
Approx(received.displacement_x).epsilon(Tolerance));
REQUIRE(h5_particle.displacement_y ==
Approx(received.displacement_y).epsilon(Tolerance));
REQUIRE(h5_particle.displacement_z ==
Approx(received.displacement_z).epsilon(Tolerance));
REQUIRE(h5_particle.nsize_x == received.nsize_x);
REQUIRE(h5_particle.nsize_y == received.nsize_y);
REQUIRE(h5_particle.nsize_z == received.nsize_z);
REQUIRE(h5_particle.velocity_x ==
Approx(received.velocity_x).epsilon(Tolerance));
REQUIRE(h5_particle.velocity_y ==
Approx(received.velocity_y).epsilon(Tolerance));
REQUIRE(h5_particle.velocity_z ==
Approx(received.velocity_z).epsilon(Tolerance));
REQUIRE(h5_particle.stress_xx ==
Approx(received.stress_xx).epsilon(Tolerance));
REQUIRE(h5_particle.stress_yy ==
Approx(received.stress_yy).epsilon(Tolerance));
REQUIRE(h5_particle.stress_zz ==
Approx(received.stress_zz).epsilon(Tolerance));
REQUIRE(h5_particle.tau_xy ==
Approx(received.tau_xy).epsilon(Tolerance));
REQUIRE(h5_particle.tau_yz ==
Approx(received.tau_yz).epsilon(Tolerance));
REQUIRE(h5_particle.tau_xz ==
Approx(received.tau_xz).epsilon(Tolerance));
REQUIRE(h5_particle.strain_xx ==
Approx(received.strain_xx).epsilon(Tolerance));
REQUIRE(h5_particle.strain_yy ==
Approx(received.strain_yy).epsilon(Tolerance));
REQUIRE(h5_particle.strain_zz ==
Approx(received.strain_zz).epsilon(Tolerance));
REQUIRE(h5_particle.gamma_xy ==
Approx(received.gamma_xy).epsilon(Tolerance));
REQUIRE(h5_particle.gamma_yz ==
Approx(received.gamma_yz).epsilon(Tolerance));
REQUIRE(h5_particle.gamma_xz ==
Approx(received.gamma_xz).epsilon(Tolerance));
REQUIRE(h5_particle.epsilon_v ==
Approx(received.epsilon_v).epsilon(Tolerance));
REQUIRE(h5_particle.status == received.status);
REQUIRE(h5_particle.cell_id == received.cell_id);
REQUIRE(h5_particle.material_id == received.cell_id);
REQUIRE(h5_particle.nstate_vars == received.nstate_vars);
for (unsigned i = 0; i < h5_particle.nstate_vars; ++i)
REQUIRE(h5_particle.svars[i] ==
Approx(h5_particle.svars[i]).epsilon(Tolerance));
}
}
// Check initialise particle from HDF5 file
SECTION("Check initialise particle with HDF5 across MPI processes") {
// Get number of MPI ranks
int mpi_size;
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
int mpi_rank;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
// If on same rank
int sender = 0;
int receiver = 0;
// Get rank and do the corresponding job for mpi size == 2
if (mpi_size == 2) receiver = 1;
// Initial particle coordinates
Eigen::Matrix<double, 3, 1> pcoordinates;
pcoordinates.setZero();
if (mpi_rank == sender) {
// Create and initialzie particle with HDF5 data
std::shared_ptr<mpm::ParticleBase<Dim>> particle =
std::make_shared<mpm::Particle<Dim>>(id, pcoordinates);
// Assign material
unsigned mid = 1;
// Initialise material
Json jmaterial;
jmaterial["density"] = 1000.;
jmaterial["youngs_modulus"] = 1.0E+7;
jmaterial["poisson_ratio"] = 0.3;
auto material =
Factory<mpm::Material<Dim>, unsigned, const Json&>::instance()
->create("LinearElastic3D", std::move(mid), jmaterial);
// Reinitialise particle from HDF5 data
REQUIRE(particle->initialise_particle(h5_particle, material) == true);
// Check particle id
REQUIRE(particle->id() == h5_particle.id);
// Check particle mass
REQUIRE(particle->mass() == h5_particle.mass);
// Check particle volume
REQUIRE(particle->volume() == h5_particle.volume);
// Check particle mass density
REQUIRE(particle->mass_density() ==
h5_particle.mass / h5_particle.volume);
// Check particle status
REQUIRE(particle->status() == h5_particle.status);
// Check for coordinates
auto coordinates = particle->coordinates();
REQUIRE(coordinates.size() == Dim);
for (unsigned i = 0; i < coordinates.size(); ++i)
REQUIRE(coordinates(i) == Approx(coords(i)).epsilon(Tolerance));
REQUIRE(coordinates.size() == Dim);
// Check for displacement
auto pdisplacement = particle->displacement();
REQUIRE(pdisplacement.size() == Dim);
for (unsigned i = 0; i < Dim; ++i)
REQUIRE(pdisplacement(i) ==
Approx(displacement(i)).epsilon(Tolerance));
// Check for size
auto size = particle->natural_size();
REQUIRE(size.size() == Dim);
for (unsigned i = 0; i < size.size(); ++i)
REQUIRE(size(i) == Approx(lsize(i)).epsilon(Tolerance));
// Check velocity
auto pvelocity = particle->velocity();
REQUIRE(pvelocity.size() == Dim);
for (unsigned i = 0; i < Dim; ++i)
REQUIRE(pvelocity(i) == Approx(velocity(i)).epsilon(Tolerance));
// Check stress
auto pstress = particle->stress();
REQUIRE(pstress.size() == stress.size());
for (unsigned i = 0; i < stress.size(); ++i)
REQUIRE(pstress(i) == Approx(stress(i)).epsilon(Tolerance));
// Check strain
auto pstrain = particle->strain();
REQUIRE(pstrain.size() == strain.size());
for (unsigned i = 0; i < strain.size(); ++i)
REQUIRE(pstrain(i) == Approx(strain(i)).epsilon(Tolerance));
// Check particle volumetric strain centroid
REQUIRE(particle->volumetric_strain_centroid() ==
h5_particle.epsilon_v);
// Check cell id
REQUIRE(particle->cell_id() == h5_particle.cell_id);
// Check material id
REQUIRE(particle->material_id() == h5_particle.material_id);
// Write Particle HDF5 data
const auto h5_send = particle->hdf5();
// Send MPI particle
MPI_Datatype paritcle_type = mpm::register_mpi_particle_type(h5_send);
MPI_Send(&h5_send, 1, paritcle_type, receiver, 0, MPI_COMM_WORLD);
mpm::deregister_mpi_particle_type(paritcle_type);
}
if (mpi_rank == receiver) {
// Receive the messid
struct mpm::HDF5Particle received;
MPI_Datatype paritcle_type = mpm::register_mpi_particle_type(received);
MPI_Recv(&received, 1, paritcle_type, sender, 0, MPI_COMM_WORLD,
MPI_STATUS_IGNORE);
mpm::deregister_mpi_particle_type(paritcle_type);
// Received particle
std::shared_ptr<mpm::ParticleBase<Dim>> rparticle =
std::make_shared<mpm::Particle<Dim>>(id, pcoordinates);
// Assign material
unsigned mid = 1;
// Initialise material
Json jmaterial;
jmaterial["density"] = 1000.;
jmaterial["youngs_modulus"] = 1.0E+7;
jmaterial["poisson_ratio"] = 0.3;
auto material =
Factory<mpm::Material<Dim>, unsigned, const Json&>::instance()
->create("LinearElastic3D", std::move(mid), jmaterial);
// Reinitialise particle from HDF5 data
REQUIRE(rparticle->initialise_particle(received, material) == true);
// Check particle id
REQUIRE(rparticle->id() == h5_particle.id);
// Check particle mass
REQUIRE(rparticle->mass() == h5_particle.mass);
// Check particle volume
REQUIRE(rparticle->volume() == h5_particle.volume);
// Check particle mass density
REQUIRE(rparticle->mass_density() ==
h5_particle.mass / h5_particle.volume);
// Check particle status
REQUIRE(rparticle->status() == h5_particle.status);
// Check for coordinates
auto coordinates = rparticle->coordinates();
REQUIRE(coordinates.size() == Dim);
for (unsigned i = 0; i < coordinates.size(); ++i)
REQUIRE(coordinates(i) == Approx(coords(i)).epsilon(Tolerance));
REQUIRE(coordinates.size() == Dim);
// Check for displacement
auto pdisplacement = rparticle->displacement();
REQUIRE(pdisplacement.size() == Dim);
for (unsigned i = 0; i < Dim; ++i)
REQUIRE(pdisplacement(i) ==
Approx(displacement(i)).epsilon(Tolerance));
// Check for size
auto size = rparticle->natural_size();
REQUIRE(size.size() == Dim);
for (unsigned i = 0; i < size.size(); ++i)
REQUIRE(size(i) == Approx(lsize(i)).epsilon(Tolerance));
// Check velocity
auto pvelocity = rparticle->velocity();
REQUIRE(pvelocity.size() == Dim);
for (unsigned i = 0; i < Dim; ++i)
REQUIRE(pvelocity(i) == Approx(velocity(i)).epsilon(Tolerance));
// Check stress
auto pstress = rparticle->stress();
REQUIRE(pstress.size() == stress.size());
for (unsigned i = 0; i < stress.size(); ++i)
REQUIRE(pstress(i) == Approx(stress(i)).epsilon(Tolerance));
// Check strain
auto pstrain = rparticle->strain();
REQUIRE(pstrain.size() == strain.size());
for (unsigned i = 0; i < strain.size(); ++i)
REQUIRE(pstrain(i) == Approx(strain(i)).epsilon(Tolerance));
// Check particle volumetric strain centroid
REQUIRE(rparticle->volumetric_strain_centroid() ==
h5_particle.epsilon_v);
// Check cell id
REQUIRE(rparticle->cell_id() == h5_particle.cell_id);
// Check material id
REQUIRE(rparticle->material_id() == h5_particle.material_id);
// Get Particle HDF5 data
const auto h5_received = rparticle->hdf5();
// State variables
REQUIRE(h5_received.nstate_vars == h5_particle.nstate_vars);
// State variables
for (unsigned i = 0; i < h5_particle.nstate_vars; ++i)
REQUIRE(h5_received.svars[i] ==
Approx(h5_particle.svars[i]).epsilon(Tolerance));
}
}
}
}
#endif // MPI
| 14,580 | 5,306 |
// Copyright 2021 The VGC Developers
// See the COPYRIGHT file at the top-level directory of this distribution
// and at https://github.com/vgc/vgc/blob/master/COPYRIGHT
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <vgc/graphics/idgenerator.h>
// Note: we need this .cpp file because even though it doesn't define any
// function, it includes the above .h file, informing the compiler about the
// IdGenerator symbol which must be exported (despite the class being
// all-inline). Not having this *.cpp file results in a linker error on
// MSVC when trying to instanciate an IdGenerator from another DLL.
namespace vgc {
namespace graphics {
} // namespace graphics
} // namespace vgc
| 1,211 | 341 |
#include "FindFirstAndLastPositionOfElementInSortedArray.h"
using namespace lcpp;
static std::vector<int>::iterator binarySearch(std::vector<int>::iterator First,
std::vector<int>::iterator Last,
int Val, bool Lower) {
while (First < Last) {
auto Mid = First + (Last - First) / 2;
if (Val < *Mid || (Lower && Val == *Mid))
Last = Mid;
else
First = Mid + 1;
}
return First;
}
std::vector<int> Solution34_1::searchRange(std::vector<int> &nums, int target) {
auto I = binarySearch(nums.begin(), nums.end(), target, true);
if (I == nums.end() || *I != target)
return {-1, -1};
return {static_cast<int>(I - nums.begin()),
static_cast<int>(binarySearch(I, nums.end(), target, false) -
nums.begin() - 1)};
}
| 875 | 278 |
#include "Event/TopLevel/EventModel.h"
#include "geometry/Vector.h"
#include "Event/Utilities/TimeStamp.h"
#include <iostream>
/// return non-zero on success
int main(){
return 0;
}
| 186 | 68 |
#ifndef MISSION_MANAGER_A_HPP_
#define MISSION_MANAGER_A_HPP_
#include "TimedControlTask.hpp"
#include "mission_mode_t.enum"
#include "adcs_mode_t.enum"
class MissionManager_a : public TimedControlTask<void> {
public:
MissionManager_a(StateFieldRegistry& registry, unsigned int offset);
void execute() override;
protected:
void set_mission_mode(mission_mode_t mode);
void calibrate_data();
void dispatch_warmup();
void dispatch_initialization();
void pause();
void tvc();
void dispatch_landed();
// Fields that control overall mission state.
/**
* @brief Current mission mode (see mission_mode_t.enum)
*/
InternalStateField<unsigned char> mission_mode_f;
InternalStateField<lin::Vector3f> acc_error_f;
InternalStateField<lin::Vector4d> init_quat_d;
InternalStateField<lin::Vector3d> euler_deg;
InternalStateField<lin::Vector2f> init_lat_long_f;
InternalStateField<float> ground_level_f;
InternalStateField<bool> engine_on_f;
InternalStateField<bool> servo_on_f;
InternalStateField<float> agl_alt_f;
InternalStateField<int> count;
InternalStateField<double> init_global_roll;
InternalStateField<float>* alt_fp;
InternalStateField<lin::Vector3f>* acc_vec_fp;
InternalStateField<lin::Vector4d>* quat_fp;
InternalStateField<lin::Vector2f>* lat_long_fp;
InternalStateField<lin::Vector3f>* lin_acc_vec_fp;
InternalStateField<lin::Vector3f>* omega_vec_fp;
InternalStateField<lin::Vector3f>* mag_vec_fp;
InternalStateField<unsigned char>* sys_cal;
InternalStateField<unsigned char>* gyro_cal;
InternalStateField<unsigned char>* accel_cal;
InternalStateField<unsigned char>* mag_cal;
long enter_init_millis;
int enter_init_ccno;
long enter_flight_millis;
int enter_freefall_cnno;
int pause_ccno;
//long enter_bellyflop_millis;
// long enter_standby_millis;
};
#endif
| 2,130 | 693 |
/// Env helper
#ifndef BELA_ENV_HPP
#define BELA_ENV_HPP
#include <string>
#include <string_view>
#include <shared_mutex>
#include "match.hpp"
#include "str_split.hpp"
#include "str_join.hpp"
#include "span.hpp"
#include "phmap.hpp"
#include "base.hpp"
namespace bela {
constexpr const wchar_t Separator = L';';
constexpr const std::wstring_view Separators = L";";
template <DWORD Len = 256> bool LookupEnv(std::wstring_view key, std::wstring &val) {
val.resize(Len);
auto len = GetEnvironmentVariableW(key.data(), val.data(), Len);
if (len == 0) {
return !(GetLastError() == ERROR_ENVVAR_NOT_FOUND);
}
if (len < Len) {
val.resize(len);
return true;
}
val.resize(len);
auto nlen = GetEnvironmentVariableW(key.data(), val.data(), len);
if (nlen < len) {
val.resize(nlen);
}
return true;
}
// GetEnv You should set the appropriate size for the initial allocation
// according to your needs.
// https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-getenvironmentvariable
template <DWORD Len = 256> std::wstring GetEnv(std::wstring_view key) {
std::wstring val;
bela::LookupEnv<Len>(key, val);
return val;
}
inline void MakePathEnv(std::vector<std::wstring> &paths) {
auto systemroot = bela::GetEnv(L"SystemRoot");
auto system32_env = bela::StringCat(systemroot, L"\\System32");
paths.emplace_back(system32_env); // C:\\Windows\\System32
paths.emplace_back(systemroot); // C:\\Windows
paths.emplace_back(bela::StringCat(system32_env, L"\\Wbem")); // C:\\Windows\\System32\\Wbem
// C:\\Windows\\System32\\WindowsPowerShell\\v1.0
paths.emplace_back(bela::StringCat(system32_env, L"\\WindowsPowerShell\\v1.0"));
}
std::wstring WindowsExpandEnv(std::wstring_view sv);
std::wstring PathUnExpand(std::wstring_view sv);
template <typename Range> std::wstring JoinEnv(const Range &range) {
return bela::strings_internal::JoinRange(range, Separators);
}
template <typename T> std::wstring JoinEnv(std::initializer_list<T> il) {
return bela::strings_internal::JoinRange(il, Separators);
}
template <typename... T> std::wstring JoinEnv(const std::tuple<T...> &value) {
return bela::strings_internal::JoinAlgorithm(value, Separators, AlphaNumFormatter());
}
template <typename... Args> std::wstring InsertEnv(std::wstring_view key, Args... arg) {
std::wstring_view svv[] = {arg...};
auto prepend = bela::JoinEnv(svv);
auto val = bela::GetEnv(key);
return bela::StringCat(prepend, Separators, val);
}
template <typename... Args> std::wstring AppendEnv(std::wstring_view key, Args... arg) {
std::wstring_view svv[] = {arg...};
auto ended = bela::JoinEnv(svv);
auto val = bela::GetEnv(key);
return bela::StringCat(val, Separators, ended);
}
} // namespace bela
#endif
| 2,818 | 1,008 |
#include "automaton/examples/network/node_prototype.h"
#include "automaton/core/io/io.h"
namespace acn = automaton::core::network;
/// Node's connection handler
node::handler::handler(node* n): node_(n) {}
void node::handler::on_message_received(acn::connection* c, char* buffer,
uint32_t bytes_read, uint32_t id) {
std::string message = std::string(buffer, bytes_read);
// logging("Message \"" + message + "\" received in <" + c->get_address() + ">");
if (std::stoul(message) > node_->height) {
node_->height = std::stoul(message);
node_->send_height();
}
c -> async_read(buffer, 16, 0, 0);
}
void node::handler::on_message_sent(acn::connection* c, uint32_t id,
acn::connection::error e) {
if (e) {
LOG(ERROR) << "Message with id " << std::to_string(id) << " was NOT sent to " <<
c->get_address() << "\nError " << std::to_string(e);
} else {
// logging("Message with id " + std::to_string(id) + " was successfully sent to " +
// c->get_address());
}
}
void node::handler::on_connected(acn::connection* c) {
c->async_read(node_->add_buffer(16), 16, 0, 0);
}
void node::handler::on_disconnected(acn::connection* c) {
// logging("Disconnected with: " + c->get_address());
}
void node::handler::on_error(acn::connection* c,
acn::connection::error e) {
if (e == acn::connection::no_error) {
return;
}
LOG(ERROR) << "Error: " << std::to_string(e) << " (connection " << c->get_address() << ")";
}
/// Node's acceptor handler
node::lis_handler::lis_handler(node* n):node_(n) {}
bool node::lis_handler::on_requested(acn::acceptor* a, const std::string& address) {
// EXPECT_EQ(address, address_a);
// logging("Connection request from: " + address + ". Accepting...");
return node_->accept_connection(/*address*/);
}
void node::lis_handler::on_connected(acn::acceptor* a, acn::connection* c,
const std::string& address) {
// logging("Accepted connection from: " + address);
node_->peers[node_->get_next_peer_id()] = c;
c->async_read(node_->add_buffer(16), 16, 0, 0);
}
void node::lis_handler::on_error(acn::acceptor* a, acn::connection::error e) {
LOG(ERROR) << std::to_string(e);
}
/// Node
node::node() {
height = 0;
peer_ids = 0;
handler_ = new handler(this);
lis_handler_ = new lis_handler(this);
}
node::~node() {
for (int i = 0; i < buffers.size(); ++i) {
delete [] buffers[i];
}
// TODO(kari): delete all acceptors and connections
}
char* node::add_buffer(uint32_t size) {
std::lock_guard<std::mutex> lock(buffer_mutex);
buffers.push_back(new char[size]);
return buffers[buffers.size() - 1];
}
/// This function is created because the acceptor needs ids for the connections it accepts
uint32_t node::get_next_peer_id() {
return ++peer_ids;
}
bool node::accept_connection() { return true; }
bool node::add_peer(uint32_t id, const std::string& connection_type, const std::string& address) {
auto it = peers.find(id);
if (it != peers.end()) {
// delete it->second; /// Delete existing acceptor
}
acn::connection* new_connection;
try {
new_connection = acn::connection::create(connection_type, address,
handler_);
} catch (std::exception& e) {
LOG(ERROR) << e.what();
peers[id] = nullptr;
return false;
}
if (!new_connection) {
LOG(ERROR) << "Connection was not created!"; // Possible reason: tcp_init was never called
return false;
}
peers[id] = new_connection;
new_connection->connect();
return true;
}
void node::remove_peer(uint32_t id) {
auto it = peers.find(id);
if (it != peers.end()) {
peers.erase(it);
}
}
bool node::add_acceptor(uint32_t id, const std::string& connection_type,
const std::string& address) {
auto it = acceptors.find(id);
if (it != acceptors.end()) {
// delete it->second; /// Delete existing acceptor
}
acn::acceptor* new_acceptor;
try {
new_acceptor = acn::acceptor::create(connection_type, address,
lis_handler_, handler_);
} catch (std::exception& e) {
LOG(ERROR) << e.what();
acceptors[id] = nullptr;
return false;
}
if (!new_acceptor) {
LOG(ERROR) << "Acceptor was not created!";
return false;
}
acceptors[id] = new_acceptor;
new_acceptor->start_accepting();
return true;
}
void node::remove_acceptor(uint32_t id) {
auto it = acceptors.find(id);
if (it != acceptors.end()) {
acceptors.erase(it);
}
}
void node::send_height(uint32_t connection_id) {
if (!connection_id) {
for (auto it = peers.begin(); it != peers.end(); ++it) {
// TODO(kari): if connected
it->second->async_send(std::to_string(height), 0);
}
} else {
peers[connection_id]->async_send(std::to_string(height), 0);
}
}
| 4,712 | 1,725 |
#include "gui_creator.h"
#include <vector>
namespace cgv {
namespace gui {
std::vector<gui_creator*>& ref_gui_creators()
{
static std::vector<gui_creator*> creators;
return creators;
}
/// register a gui creator
void register_gui_creator(gui_creator* gc, const char* creator_name)
{
ref_gui_creators().push_back(gc);
}
/// create the gui for a composed structure
bool create_gui(provider* p, const std::string& label,
void* value_ptr, const std::string& value_type,
const std::string& gui_type, const std::string& options, bool* toggles)
{
for (unsigned i=0; i<ref_gui_creators().size(); ++i)
if (ref_gui_creators()[i]->create(p,label,value_ptr,value_type,gui_type,options,toggles))
return true;
return false;
}
}
} | 739 | 287 |
/*
* Copyright Nick Thompson, 2020
* Use, modification and distribution are subject to the
* Boost Software License, Version 1.0. (See accompanying file
* LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#include "math_unit_test.hpp"
#include <numeric>
#include <utility>
#include <random>
#include <boost/math/interpolators/pchip.hpp>
#include <boost/circular_buffer.hpp>
#include <boost/assert.hpp>
#ifdef BOOST_HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
using boost::multiprecision::float128;
#endif
using boost::math::interpolators::pchip;
template<typename Real>
void test_constant()
{
std::vector<Real> x{0,1,2,3, 9, 22, 81};
std::vector<Real> y(x.size());
for (auto & t : y) {
t = 7;
}
auto x_copy = x;
auto y_copy = y;
auto pchip_spline = pchip(std::move(x_copy), std::move(y_copy));
//std::cout << "Constant value pchip spline = " << pchip_spline << "\n";
for (Real t = x[0]; t <= x.back(); t += 0.25) {
CHECK_ULP_CLOSE(Real(7), pchip_spline(t), 2);
CHECK_ULP_CLOSE(Real(0), pchip_spline.prime(t), 2);
}
boost::circular_buffer<Real> x_buf(x.size());
for (auto & t : x) {
x_buf.push_back(t);
}
boost::circular_buffer<Real> y_buf(x.size());
for (auto & t : y) {
y_buf.push_back(t);
}
auto circular_pchip_spline = pchip(std::move(x_buf), std::move(y_buf));
for (Real t = x[0]; t <= x.back(); t += 0.25) {
CHECK_ULP_CLOSE(Real(7), circular_pchip_spline(t), 2);
CHECK_ULP_CLOSE(Real(0), pchip_spline.prime(t), 2);
}
circular_pchip_spline.push_back(x.back() + 1, 7);
CHECK_ULP_CLOSE(Real(0), circular_pchip_spline.prime(x.back()+1), 2);
}
template<typename Real>
void test_linear()
{
std::vector<Real> x{0,1,2,3};
std::vector<Real> y{0,1,2,3};
auto x_copy = x;
auto y_copy = y;
auto pchip_spline = pchip(std::move(x_copy), std::move(y_copy));
CHECK_ULP_CLOSE(y[0], pchip_spline(x[0]), 0);
CHECK_ULP_CLOSE(Real(1)/Real(2), pchip_spline(Real(1)/Real(2)), 10);
CHECK_ULP_CLOSE(y[1], pchip_spline(x[1]), 0);
CHECK_ULP_CLOSE(Real(3)/Real(2), pchip_spline(Real(3)/Real(2)), 10);
CHECK_ULP_CLOSE(y[2], pchip_spline(x[2]), 0);
CHECK_ULP_CLOSE(Real(5)/Real(2), pchip_spline(Real(5)/Real(2)), 10);
CHECK_ULP_CLOSE(y[3], pchip_spline(x[3]), 0);
x.resize(45);
y.resize(45);
for (size_t i = 0; i < x.size(); ++i) {
x[i] = i;
y[i] = i;
}
x_copy = x;
y_copy = y;
pchip_spline = pchip(std::move(x_copy), std::move(y_copy));
for (Real t = 0; t < x.back(); t += 0.5) {
CHECK_ULP_CLOSE(t, pchip_spline(t), 0);
CHECK_ULP_CLOSE(Real(1), pchip_spline.prime(t), 0);
}
x_copy = x;
y_copy = y;
// Test endpoint derivatives:
pchip_spline = pchip(std::move(x_copy), std::move(y_copy), Real(1), Real(1));
for (Real t = 0; t < x.back(); t += 0.5) {
CHECK_ULP_CLOSE(t, pchip_spline(t), 0);
CHECK_ULP_CLOSE(Real(1), pchip_spline.prime(t), 0);
}
boost::circular_buffer<Real> x_buf(x.size());
for (auto & t : x) {
x_buf.push_back(t);
}
boost::circular_buffer<Real> y_buf(x.size());
for (auto & t : y) {
y_buf.push_back(t);
}
auto circular_pchip_spline = pchip(std::move(x_buf), std::move(y_buf));
for (Real t = x[0]; t <= x.back(); t += 0.25) {
CHECK_ULP_CLOSE(t, circular_pchip_spline(t), 2);
CHECK_ULP_CLOSE(Real(1), circular_pchip_spline.prime(t), 2);
}
circular_pchip_spline.push_back(x.back() + 1, y.back()+1);
CHECK_ULP_CLOSE(Real(y.back() + 1), circular_pchip_spline(Real(x.back()+1)), 2);
CHECK_ULP_CLOSE(Real(1), circular_pchip_spline.prime(Real(x.back()+1)), 2);
}
template<typename Real>
void test_interpolation_condition()
{
for (size_t n = 4; n < 50; ++n) {
std::vector<Real> x(n);
std::vector<Real> y(n);
std::default_random_engine rd;
std::uniform_real_distribution<Real> dis(0,1);
Real x0 = dis(rd);
x[0] = x0;
y[0] = dis(rd);
for (size_t i = 1; i < n; ++i) {
x[i] = x[i-1] + dis(rd);
y[i] = dis(rd);
}
auto x_copy = x;
auto y_copy = y;
auto s = pchip(std::move(x_copy), std::move(y_copy));
//std::cout << "s = " << s << "\n";
for (size_t i = 0; i < x.size(); ++i) {
CHECK_ULP_CLOSE(y[i], s(x[i]), 2);
}
x_copy = x;
y_copy = y;
// The interpolation condition is not affected by the endpoint derivatives, even though these derivatives might be super weird:
s = pchip(std::move(x_copy), std::move(y_copy), Real(0), Real(0));
//std::cout << "s = " << s << "\n";
for (size_t i = 0; i < x.size(); ++i) {
CHECK_ULP_CLOSE(y[i], s(x[i]), 2);
}
}
}
template<typename Real>
void test_monotonicity()
{
for (size_t n = 4; n < 50; ++n) {
std::vector<Real> x(n);
std::vector<Real> y(n);
std::default_random_engine rd;
std::uniform_real_distribution<Real> dis(0,1);
Real x0 = dis(rd);
x[0] = x0;
y[0] = dis(rd);
// Monotone increasing:
for (size_t i = 1; i < n; ++i) {
x[i] = x[i-1] + dis(rd);
y[i] = y[i-1] + dis(rd);
}
auto x_copy = x;
auto y_copy = y;
auto s = pchip(std::move(x_copy), std::move(y_copy));
//std::cout << "s = " << s << "\n";
for (size_t i = 0; i < x.size() - 1; ++i) {
Real tmin = x[i];
Real tmax = x[i+1];
Real val = y[i];
CHECK_ULP_CLOSE(y[i], s(x[i]), 2);
for (Real t = tmin; t < tmax; t += (tmax-tmin)/16) {
Real greater_val = s(t);
BOOST_ASSERT(val <= greater_val);
val = greater_val;
}
}
x[0] = dis(rd);
y[0] = dis(rd);
// Monotone decreasing:
for (size_t i = 1; i < n; ++i) {
x[i] = x[i-1] + dis(rd);
y[i] = y[i-1] - dis(rd);
}
x_copy = x;
y_copy = y;
s = pchip(std::move(x_copy), std::move(y_copy));
//std::cout << "s = " << s << "\n";
for (size_t i = 0; i < x.size() - 1; ++i) {
Real tmin = x[i];
Real tmax = x[i+1];
Real val = y[i];
CHECK_ULP_CLOSE(y[i], s(x[i]), 2);
for (Real t = tmin; t < tmax; t += (tmax-tmin)/16) {
Real lesser_val = s(t);
BOOST_ASSERT(val >= lesser_val);
val = lesser_val;
}
}
}
}
int main()
{
#if (__GNUC__ > 7) || defined(_MSC_VER) || defined(__clang__)
test_constant<float>();
test_linear<float>();
test_interpolation_condition<float>();
test_monotonicity<float>();
test_constant<double>();
test_linear<double>();
test_interpolation_condition<double>();
test_monotonicity<double>();
test_constant<long double>();
test_linear<long double>();
test_interpolation_condition<long double>();
test_monotonicity<long double>();
#ifdef BOOST_HAS_FLOAT128
test_constant<float128>();
test_linear<float128>();
#endif
#endif
return boost::math::test::report_errors();
}
| 7,345 | 3,091 |
#include "LauncherSystem.h"
void LauncherSystem::Update(){
std::set<Entity*> current_missile=engine_.GetEntityStream().WithTag(Component::Tag::CURRENTMISSILE); // ask for sprites, all entities containing a sprite have to use a scaled bitmap
if (current_missile.empty()){
context_.changing=true;
std::set<Entity*> missiles;
PolygonComponent * pg;
Point increment=Point((MISSILE_DST_WIDTH+MISSILE_SPACING),0);
Point new_pos;
for(int i=0;i<MISS_NR;i++){
missiles=engine_.GetEntityStream().WithTag(missile_list[i]);
std::set<Entity*>::iterator it=missiles.begin();
for(;it!=missiles.end();it++){
pg=(PolygonComponent*)(*it)->GetComponent(Component::Tag::POLYGON);
new_pos=pg->get_position()+increment;
pg->set_position(new_pos);
if(pg->get_position().x_>((MISS_NR-1)*(MISSILE_SPACING+MISSILE_DST_WIDTH))){
Point current=Point(MISSILEX,MISSILEY);
CurrentMissileComponent * curr=new CurrentMissileComponent;
(*it)->Add(curr);
engine_.UpdateEntity((*it),(*it)->GetTags(),false);
pg->set_position(current);
CircleComponent * circle =(CircleComponent*)(*it)->GetComponent(Component::Tag::CIRCLE);
if (circle!=NULL){
circle->set_pos(current);
}
}
}
}
Entity * ent=new Entity;
RandomMissile(0,Y_OFFSET,ent);
engine_.AddEntity(ent);
}
// TODO click release check & zo ja positie van muis gelijkstellen aan x,y
// als het gereleased is snelheid bepalen!
else{
std::set<Entity*>::iterator it=current_missile.begin();// onlyone missile
CurrentMissileComponent * Cm=(CurrentMissileComponent*)(*it)->GetComponent(Component::Tag::CURRENTMISSILE);
if(!Cm->fired){
PolygonComponent * pg=(PolygonComponent*)(*it)->GetComponent(Component::Tag::POLYGON);
if(!Cm->selected){
bool collision;
CircleComponent * cr=(CircleComponent*)(*it)->GetComponent(Component::Tag::CIRCLE);
// Check for collision
if (cr!=NULL){
collision=CircleCollision_(context_.mouse,cr->get_center(),cr->radius);
}else{
collision=PolyCollision_(context_.mouse,pg->get_polygon());
}
// check if we clicked
if (collision and context_.clicked){
Cm->selected=true;
Cm->ClickCorrect=context_.mouse-pg->get_position();
}
}else{
context_.changing=true;
if (context_.mouse.x_<MISSILEX){
Point current_pos=context_.mouse-Cm->ClickCorrect;
pg->set_position(current_pos); //Only set position of the polygon, the circle will only be used for the collision check so no sets are required here
}
//std::cout<<"selected!!"<<std::endl;
if(context_.released){
//std::cout<<"changing the status to fired"<<std::endl;
Cm->fired=true;
Point speed_vector=Point(MISSILEX,MISSILEY)-(context_.mouse-Cm->ClickCorrect);
Cm->speed.x_=KSPEED*speed_vector.x_;
Cm->speed.y_=KSPEED*speed_vector.y_; //KSPEED is a proportional value to play with
}
}
}
}
}
bool LauncherSystem::CircleCollision_(Point& mouse,Point& center,double radius){
double length=mouse*center;
//std::cout<<"the length is"<<length<<std::endl;
bool collision=length<radius;
//std::cout<<"collision"<<collision<<std::endl;
return collision;
}
bool LauncherSystem::PolyCollision_(Point& mouse,std::vector<Point>& poly){
/* Some ugly copy and paste was done here, not using the functions directly from TargetSystems with the goal to
keep the systems seperated for readability + future work*/
bool collision = true;
std::vector<Point> edges_poly = GetEdges(poly);
Point edge;
std::vector<Point> mouse_point{mouse}; // made a vector such that the functions don't have to be changed
// Loop through all the edges of both polygons
for (std::size_t edge_id = 0; edge_id < edges_poly.size(); edge_id++) {
edge = edges_poly[edge_id];
// Find perpendicular axis to current edge
Point axis(-edge.y_, edge.x_);
axis.Normalize();
// Find projection of polygon on current axis
double min_dotp_poly = 0;
double max_dotp_poly = 0;
double dotp_mouse = 0;
ProjectOnAxis(poly, axis, min_dotp_poly, max_dotp_poly);
ProjectOnAxis(mouse_point, axis, dotp_mouse, dotp_mouse); // dotp_mouse in twice for function compatibility
// Check if polygon projections overlap
if (DistanceBetweenPolys(min_dotp_poly, max_dotp_poly, dotp_mouse) > 0) {
collision = false;
break;
}
}
return collision;
}
std::vector<Point> LauncherSystem::GetEdges(std::vector<Point>& coordinates) {
std::vector<Point> edges;
Point prevPoint = coordinates[0];
for (std::size_t i = 1; i < coordinates.size(); i++) {
edges.push_back(coordinates[i] - prevPoint);
prevPoint = coordinates[i];
}
edges.push_back(coordinates[0] - prevPoint);
return edges;
}
void LauncherSystem::ProjectOnAxis(std::vector<Point>& coordinates, Point& axis, double& min, double& max) {
double dotp = coordinates[0] >> axis;
min = dotp;
max = dotp;
for (std::size_t i = 0; i < coordinates.size(); i++) {
dotp = coordinates[i] >> axis;
if (dotp < min) {
min = dotp;
}
else if (dotp > max) {
max = dotp;
}
}
}
double LauncherSystem::DistanceBetweenPolys(double min_dotp_poly, double max_dotp_poly, double dotp_mouse) {
if (min_dotp_poly < dotp_mouse) {
return dotp_mouse - max_dotp_poly;
}
else {
return min_dotp_poly - dotp_mouse;
}
}
| 6,356 | 1,889 |
#include "json.hpp"
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <exception>
using json = nlohmann::json;
using namespace std;
int main(){
// 序列化
// 普通数据序列化
json js;
js["id"] = {1,2,3,4,5};
js["name"] = "zhang san";
js["msg"]["zhang san"] = "hello world";
js["msg"]["liu shuo"] = "hello from liu shuo";
cout << js <<endl;
// 容器序列化
json js_;
vector<int> vec{1,2,5};
js_["list"] = vec;
map<int,string> m{{1,"一"},{2,"二"},{3,"三"}};
js_["num"] = m;
cout << js_ <<endl;
// 显式dump
cout << js_.dump()<<endl;
// 反序列化
cout << endl;
string json_str = js.dump();
cout << "receive: " << json_str<<endl;
json js2_parsed = json::parse(json_str);
// 允许空格、回车等
json js3_parsed = json::parse("{\"msgid\":4,\"id\": 540000 } \n");
cout << "allow some noise like \\n and space" << js3_parsed.dump() <<endl;
// 可以使用find检查键
cout << "json above has id "<<(js3_parsed.find("id")!=js3_parsed.end() )<< endl;
cout << "json above has name "<<(js3_parsed.find("name")!=js3_parsed.end()) << endl;
// 反序列化get为string
json js_ex ;
js_ex["msg"] = "message";
string js_ex_str = js_ex.dump();
json js_ex_r = json::parse( js_ex_str);
cout <<"use [\"tag\"] directly : "<< js_ex_r["msg"] << endl;
cout <<"use get<string> : "<< js_ex_r["msg"].get<string>()<< endl;
// 单个变量
auto name = js2_parsed["name"];
cout << "name: " << name <<endl;
// 容器
auto v = js2_parsed["id"];
cout << "id : ";
for(const auto& x : v){
cout << x << " ";
}
cout << endl;
// 容器
map<string,string> name_sentence = js2_parsed["msg"];
for(const auto& x : name_sentence){
cout << x.first << " : " <<x.second<<endl;
}
cout <<endl;
// 多个json : 不行
try{
string two_js_str = js_ex.dump();
two_js_str += js_ex.dump();
cout << two_js_str <<endl;
json two_js = json::parse(two_js_str);
} catch (exception E){
cout << E.what()<<endl;
}
} | 2,092 | 880 |
/// @copyright
/// Copyright (C) 2020 Assured Information Security, Inc.
///
/// @copyright
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// @copyright
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// @copyright
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
/// SOFTWARE.
#ifndef EXT_POOL_T_HPP
#define EXT_POOL_T_HPP
#include <bsl/array.hpp>
#include <bsl/as_const.hpp>
#include <bsl/debug.hpp>
#include <bsl/errc_type.hpp>
#include <bsl/finally.hpp>
#include <bsl/move.hpp>
#include <bsl/touch.hpp>
#include <bsl/unlikely.hpp>
namespace mk
{
/// @class mk::ext_pool_t
///
/// <!-- description -->
/// @brief TODO
///
/// <!-- template parameters -->
/// @tparam EXT_CONCEPT the type of ext_t that this class manages.
/// @tparam INTRINSIC_CONCEPT defines the type of intrinsics to use
/// @tparam PAGE_POOL_CONCEPT defines the type of page pool to use
/// @tparam ROOT_PAGE_TABLE_CONCEPT defines the type of RPT pool to use
/// @tparam MAX_EXTENSIONS the max number of extensions supported
///
template<
typename EXT_CONCEPT,
typename INTRINSIC_CONCEPT,
typename PAGE_POOL_CONCEPT,
typename ROOT_PAGE_TABLE_CONCEPT,
bsl::uintmax MAX_EXTENSIONS>
class ext_pool_t final
{
/// @brief stores a reference to the intrinsics to use
INTRINSIC_CONCEPT &m_intrinsic;
/// @brief stores a reference to the page pool to use
PAGE_POOL_CONCEPT &m_page_pool;
/// @brief stores system RPT provided by the loader
ROOT_PAGE_TABLE_CONCEPT &m_system_rpt;
/// @brief stores all of the extensions.
bsl::array<EXT_CONCEPT, MAX_EXTENSIONS> m_ext_pool;
public:
/// @brief an alias for EXT_CONCEPT
using ext_type = EXT_CONCEPT;
/// @brief an alias for INTRINSIC_CONCEPT
using intrinsic_type = INTRINSIC_CONCEPT;
/// @brief an alias for PAGE_POOL_CONCEPT
using page_pool_type = PAGE_POOL_CONCEPT;
/// @brief an alias for ROOT_PAGE_TABLE_CONCEPT
using root_page_table_type = ROOT_PAGE_TABLE_CONCEPT;
/// <!-- description -->
/// @brief Creates a ext_pool_t
///
/// <!-- inputs/outputs -->
/// @param intrinsic the intrinsics to use
/// @param page_pool the page pool to use
/// @param system_rpt the system RPT provided by the loader
///
explicit constexpr ext_pool_t(
INTRINSIC_CONCEPT &intrinsic,
PAGE_POOL_CONCEPT &page_pool,
ROOT_PAGE_TABLE_CONCEPT &system_rpt) noexcept
: m_intrinsic{intrinsic}, m_page_pool{page_pool}, m_system_rpt{system_rpt}, m_ext_pool{}
{}
/// <!-- description -->
/// @brief Initializes this ext_pool_t
///
/// <!-- inputs/outputs -->
/// @tparam EXT_ELF_FILES_CONCEPT the type of array containing the
/// ext_elf_files provided by the loader
/// @param ext_elf_files the ext_elf_files provided by the loader
/// @param online_pps the total number of PPs that are online
/// @return Returns bsl::errc_success on success, bsl::errc_failure
/// otherwise
///
template<typename EXT_ELF_FILES_CONCEPT>
[[nodiscard]] constexpr auto
initialize(EXT_ELF_FILES_CONCEPT const &ext_elf_files, bsl::safe_uint16 const &online_pps)
&noexcept -> bsl::errc_type
{
bsl::errc_type ret{};
if (bsl::unlikely(ext_elf_files.size() != m_ext_pool.size())) {
bsl::error() << "invalid ext_elf_file\n" << bsl::here();
return bsl::errc_failure;
}
bsl::finally release_on_error{[this]() noexcept -> void {
this->release();
}};
for (auto const ext : m_ext_pool) {
if (ext_elf_files.at_if(ext.index)->empty()) {
break;
}
ret = ext.data->initialize(
&m_intrinsic,
&m_page_pool,
bsl::to_u16(ext.index),
*ext_elf_files.at_if(ext.index),
online_pps,
&m_system_rpt);
if (bsl::unlikely(!ret)) {
bsl::print<bsl::V>() << bsl::here();
return bsl::errc_failure;
}
bsl::touch();
}
release_on_error.ignore();
return bsl::errc_success;
}
/// <!-- description -->
/// @brief Release the ext_pool_t
///
constexpr void
release() &noexcept
{
for (auto const ext : m_ext_pool) {
ext.data->release();
}
}
/// <!-- description -->
/// @brief Destroyes a previously created ext_pool_t
///
constexpr ~ext_pool_t() noexcept = default;
/// <!-- description -->
/// @brief copy constructor
///
/// <!-- inputs/outputs -->
/// @param o the object being copied
///
constexpr ext_pool_t(ext_pool_t const &o) noexcept = delete;
/// <!-- description -->
/// @brief move constructor
///
/// <!-- inputs/outputs -->
/// @param o the object being moved
///
constexpr ext_pool_t(ext_pool_t &&o) noexcept = default;
/// <!-- description -->
/// @brief copy assignment
///
/// <!-- inputs/outputs -->
/// @param o the object being copied
/// @return a reference to *this
///
[[maybe_unused]] constexpr auto operator=(ext_pool_t const &o) &noexcept
-> ext_pool_t & = delete;
/// <!-- description -->
/// @brief move assignment
///
/// <!-- inputs/outputs -->
/// @param o the object being moved
/// @return a reference to *this
///
[[maybe_unused]] constexpr auto operator=(ext_pool_t &&o) &noexcept
-> ext_pool_t & = default;
/// <!-- description -->
/// @brief Starts this ext_pool_t by calling all of the
/// extension's _start entry points.
///
/// <!-- inputs/outputs -->
/// @tparam TLS_CONCEPT defines the type of TLS block to use
/// @param tls the current TLS block
/// @return Returns bsl::errc_success on success, bsl::errc_failure
/// otherwise
///
template<typename TLS_CONCEPT>
[[nodiscard]] constexpr auto
start(TLS_CONCEPT &tls) &noexcept -> bsl::errc_type
{
for (auto const ext : m_ext_pool) {
if (bsl::unlikely(!ext.data->start(tls))) {
bsl::print<bsl::V>() << bsl::here();
return bsl::errc_failure;
}
bsl::touch();
}
return bsl::errc_success;
}
/// <!-- description -->
/// @brief Bootstraps this ext_pool_t by calling all of the
/// registered bootstrap callbacks for each extension.
///
/// <!-- inputs/outputs -->
/// @tparam TLS_CONCEPT defines the type of TLS block to use
/// @param tls the current TLS block
/// @return Returns bsl::errc_success on success, bsl::errc_failure
/// otherwise
///
template<typename TLS_CONCEPT>
[[nodiscard]] constexpr auto
bootstrap(TLS_CONCEPT &tls) &noexcept -> bsl::errc_type
{
for (auto const ext : m_ext_pool) {
if (bsl::unlikely(!ext.data->bootstrap(tls))) {
bsl::print<bsl::V>() << bsl::here();
return bsl::errc_failure;
}
bsl::touch();
}
if (bsl::unlikely(nullptr == tls.ext_vmexit)) {
bsl::error() << "a vmexit handler has not been registered" // --
<< bsl::endl // --
<< bsl::here(); // --
return bsl::errc_failure;
}
if (bsl::unlikely(nullptr == tls.ext_fail)) {
bsl::error() << "a fast fail handler has not been registered" // --
<< bsl::endl // --
<< bsl::here(); // --
return bsl::errc_failure;
}
return bsl::errc_success;
}
};
}
#endif
| 9,698 | 2,920 |
#include "../../Extras/Serialize/BulletFileLoader/bFile.h"
#include <btBulletDynamicsCommon.h>
#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
#include "../../Extras/Serialize/BulletWorldImporter/btMultiBodyWorldImporter.h"
#include "../../Extras/Serialize/BulletWorldImporter/btBulletWorldImporter.h"
#include "../../Extras/Serialize/BulletWorldImporter/btWorldImporter.h"
#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
#include "LinearMath/btVector3.h"
#include <gtest/gtest.h>
static btMultiBodyDynamicsWorld *create_btMultiBodyDynamicsWorld()
{
btDefaultCollisionConfiguration * collisionConfiguration = new btDefaultCollisionConfiguration();
btCollisionDispatcher * dispatcher = new btCollisionDispatcher(collisionConfiguration);
btDbvtBroadphase * broadphase = new btDbvtBroadphase();
btMultiBodyConstraintSolver* solver = new btMultiBodyConstraintSolver();
btMultiBodyDynamicsWorld * world = new btMultiBodyDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
world->setGravity(btVector3(0, -10, 0));
return world;
}
btRigidBody* CreateBox(btVector3 position, btVector3 velocity, btVector3 inertia, btScalar mass = 1.f)
{
btBoxShape* colShape = new btBoxShape(btVector3(.1, .1, .1));
btTransform startTransform;
startTransform.setIdentity();
startTransform.setOrigin(position);
colShape->calculateLocalInertia(mass, inertia);
btRigidBody* box = new btRigidBody(mass, 0, colShape, inertia);
box->setWorldTransform(startTransform);
box->setUserIndex(-1);
box->setLinearVelocity(velocity);
return box;
}
GTEST_TEST(BulletDynamics, DeterministicSaveRestore)
{
static char filename[] = "test_serialize.bullet";
btRigidBody* box_before[3];
btCollisionObject* box_after[3];
btMultiBodyDynamicsWorld *initial_world = create_btMultiBodyDynamicsWorld();
// create ground plane and box shapes
// in test three boxes are created
btBoxShape* groundShape = new btBoxShape(btVector3(btScalar(50.), btScalar(50.), btScalar(50.)));
{
btTransform groundTransform;
groundTransform.setIdentity();
groundTransform.setOrigin(btVector3(0, -50, 0));
btScalar mass(0.);
btVector3 localInertia(0, 0, 0);
groundShape->calculateLocalInertia(mass, localInertia);
btRigidBody* body = new btRigidBody(mass, 0, groundShape, localInertia);
body->setWorldTransform(groundTransform);
body->setUserIndex(-1);
initial_world->addRigidBody(body);
}
{
btVector3 localInertia(0, 0, 0);
//set first position of boxes and linear velocity
box_before[0] = CreateBox(btVector3(2,10,0), btVector3(-1,0,1), localInertia);
initial_world->addRigidBody(box_before[0]);
box_before[1] = CreateBox(btVector3(2,10,2), btVector3(-1,0,-1), localInertia);
initial_world->addRigidBody(box_before[1]);
box_before[2] = CreateBox(btVector3(0,10,1), btVector3(1,0,0), localInertia);
initial_world->addRigidBody(box_before[2]);
}
// step simulation until collision
const double delta_t = 0.01;
int time = 0;
while (box_before[0]->getCenterOfMassPosition().getY() == box_before[1]->getCenterOfMassPosition().getY() &&
box_before[1]->getCenterOfMassPosition().getY() == box_before[2]->getCenterOfMassPosition().getY())
{
time++;
initial_world->stepSimulation(delta_t);
}
// serialize
if (initial_world->getDispatcher()->getNumManifolds() < 2)
{
printf("Error: too little manifolds\n");
exit(1);
}
const btVector3 before_serialize1 = box_before[0]->getCenterOfMassPosition();
const btVector3 before_serialize2 = box_before[1]->getCenterOfMassPosition();
const btVector3 before_serialize3 = box_before[2]->getCenterOfMassPosition();
btSerializer* s = new btDefaultSerializer;
initial_world->serialize(s);
FILE* file = fopen(filename, "wb");
fwrite(s->getBufferPointer(), s->getCurrentBufferSize(), 1, file);
fclose(file);
// step simulation until boxes are no longer moving
for (int i = 0; i < 500; ++i)
{
time++;
initial_world->stepSimulation(delta_t);
}
// save position of all boxes
const btVector3 steady_state1 = box_before[0]->getCenterOfMassPosition();
const btVector3 steady_state2 = box_before[1]->getCenterOfMassPosition();
const btVector3 steady_state3 = box_before[2]->getCenterOfMassPosition();
// deserialize
btMultiBodyDynamicsWorld *deserialized_world = create_btMultiBodyDynamicsWorld();
btMultiBodyWorldImporter importer(deserialized_world);
importer.loadFile(filename);
box_after[0] = importer.getRigidBodyByIndex(1);
box_after[1] = importer.getRigidBodyByIndex(2);
box_after[2] = importer.getRigidBodyByIndex(3);
// step simulation until boxes are no longer moving
for (int i = 0; i < 500; ++i)
{
time++;
deserialized_world->stepSimulation(delta_t);
}
const btVector3 after_deserialize1 = box_after[0]->getCenterOfMassPosition();
const btVector3 after_deserialize2 = box_after[1]->getCenterOfMassPosition();
const btVector3 after_deserialize3 = box_after[2]->getCenterOfMassPosition();
// assert that the position of all boxes in deserialized_world are the same as in initial_world
EXPECT_FLOAT_EQ(steady_state1.getX(),after_deserialize1.getX());
EXPECT_FLOAT_EQ(steady_state1.getY(),after_deserialize1.getY());
EXPECT_FLOAT_EQ(steady_state1.getZ(),after_deserialize1.getZ());
EXPECT_FLOAT_EQ(steady_state2.getX(),after_deserialize2.getX());
EXPECT_FLOAT_EQ(steady_state2.getY(),after_deserialize2.getY());
EXPECT_FLOAT_EQ(steady_state2.getZ(),after_deserialize2.getZ());
EXPECT_FLOAT_EQ(steady_state3.getX(),after_deserialize3.getX());
EXPECT_FLOAT_EQ(steady_state3.getY(),after_deserialize3.getY());
EXPECT_FLOAT_EQ(steady_state3.getZ(),after_deserialize3.getZ());
}
int main(int argc, char** argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 5,884 | 2,240 |
// ----------------------------------------------------------------------------
// FILE: LutronHWC_Data.cpp
// DATE: Fri, Feb 12 21:14:17 2021 -0500
//
// This file was generated by the Charmed Quark CIDIDL compiler. Do not make
// changes by hand, because they will be lost if the file is regenerated.
// ----------------------------------------------------------------------------
#include "LutronHWC_.hpp"
const TString kLutronHWC::strAttr_Addr(L"/Attr/Addr");
const TString kLutronHWC::strAttr_Name(L"/Attr/Name");
const TString kLutronHWC::strAttr_Number(L"/Attr/Number");
static TEnumMap::TEnumValItem aeitemValues_EListCols[4] =
{
{ tCIDLib::TInt4(tLutronHWC::EListCols::Type), 0, 0, { L"", L"", L"", L"Type", L"EListCols::Type", L"" } }
, { tCIDLib::TInt4(tLutronHWC::EListCols::Name), 0, 0, { L"", L"", L"", L"Name", L"EListCols::Name", L"" } }
, { tCIDLib::TInt4(tLutronHWC::EListCols::Address), 0, 0, { L"", L"", L"", L"Address", L"EListCols::Address", L"" } }
, { tCIDLib::TInt4(tLutronHWC::EListCols::Number), 0, 0, { L"", L"", L"", L"Number", L"EListCols::Number", L"" } }
};
static TEnumMap emapEListCols
(
L"EListCols"
, 4
, kCIDLib::False
, aeitemValues_EListCols
, nullptr
, tCIDLib::TCard4(tLutronHWC::EListCols::Count)
);
const TString& tLutronHWC::strXlatEListCols(const tLutronHWC::EListCols eVal, const tCIDLib::TBoolean bThrowIfNot)
{
return emapEListCols.strMapEnumVal(tCIDLib::TCard4(eVal), TEnumMap::ETextVals::BaseName, bThrowIfNot);
}
tLutronHWC::EListCols tLutronHWC::eXlatEListCols(const TString& strVal, const tCIDLib::TBoolean bThrowIfNot)
{
return tLutronHWC::EListCols(emapEListCols.i4MapEnumText(strVal, TEnumMap::ETextVals::BaseName, bThrowIfNot));
}
tCIDLib::TBoolean tLutronHWC::bIsValidEnum(const tLutronHWC::EListCols eVal)
{
return emapEListCols.bIsValidEnum(tCIDLib::TCard4(eVal));
}
static TEnumMap::TEnumValItem aeitemValues_EItemTypes[3] =
{
{ tCIDLib::TInt4(tLutronHWC::EItemTypes::Button), 0, 0, { L"", L"", L"", L"Button", L"EItemTypes::Button", L"" } }
, { tCIDLib::TInt4(tLutronHWC::EItemTypes::Dimmer), 0, 0, { L"", L"", L"", L"Dimmer", L"EItemTypes::Dimmer", L"" } }
, { tCIDLib::TInt4(tLutronHWC::EItemTypes::LED), 0, 0, { L"", L"", L"", L"LED", L"EItemTypes::LED", L"" } }
};
static TEnumMap emapEItemTypes
(
L"EItemTypes"
, 3
, kCIDLib::False
, aeitemValues_EItemTypes
, nullptr
, tCIDLib::TCard4(tLutronHWC::EItemTypes::Count)
);
const TString& tLutronHWC::strXlatEItemTypes(const tLutronHWC::EItemTypes eVal, const tCIDLib::TBoolean bThrowIfNot)
{
return emapEItemTypes.strMapEnumVal(tCIDLib::TCard4(eVal), TEnumMap::ETextVals::BaseName, bThrowIfNot);
}
tLutronHWC::EItemTypes tLutronHWC::eXlatEItemTypes(const TString& strVal, const tCIDLib::TBoolean bThrowIfNot)
{
return tLutronHWC::EItemTypes(emapEItemTypes.i4MapEnumText(strVal, TEnumMap::ETextVals::BaseName, bThrowIfNot));
}
TTextOutStream& tLutronHWC::operator<<(TTextOutStream& strmTar, const tLutronHWC::EItemTypes eVal)
{
strmTar << emapEItemTypes.strMapEnumVal(tCIDLib::TCard4(eVal), TEnumMap::ETextVals::BaseName, kCIDLib::False);
return strmTar;
}
tCIDLib::TBoolean tLutronHWC::bIsValidEnum(const tLutronHWC::EItemTypes eVal)
{
return emapEItemTypes.bIsValidEnum(tCIDLib::TCard4(eVal));
}
| 3,361 | 1,493 |
#include <stdexcept>
#include <boost/python/object.hpp>
#include <boost/python/import.hpp>
#include <boost/python/exec.hpp>
#include <boost/python/dict.hpp>
#include "python/plugin.h"
#include "python/helpers.h"
#include "detail/logging.h"
#include "offset_store.h"
using std::string;
using std::vector;
using std::once_flag;
using std::call_once;
using std::runtime_error;
using boost::optional;
namespace python = boost::python;
namespace pirulo {
namespace api {
PIRULO_CREATE_LOGGER("p.python");
PythonPlugin::PythonPlugin(const string& modules_path, const string& file_path) {
helpers::initialize_python();
helpers::GILAcquirer _;
// Dirtiness taken from https://wiki.python.org/moin/boost.python/EmbeddingPython
python::dict locals;
python::object main_module = python::import("__main__");
python::object main_namespace = main_module.attr("__dict__");
locals["modules_path"] = modules_path;
locals["path"] = file_path;
try {
python::exec("import imp, sys, os.path\n"
"sys.path.append(os.path.abspath(modules_path))\n"
"module_name = os.path.basename(path)[:-3]\n"
"module = imp.load_module(module_name,open(path),path,('py','U',imp.PY_SOURCE))\n",
main_namespace, locals);
}
catch (const python::error_already_set& ex) {
LOG4CXX_ERROR(logger, "Failed to load module " << file_path
<< ": " << helpers::format_python_exception());
throw runtime_error("Error loading python plugin " + file_path);
}
try {
python::object plugin_factory = locals["module"].attr("create_plugin");
plugin_ = plugin_factory();
}
catch (const python::error_already_set& ex) {
LOG4CXX_ERROR(logger, "Error instantiating Plugin classs on module " << file_path
<< ": " << helpers::format_python_exception());
throw runtime_error("Error instanting python plugin " + file_path);
}
}
PythonPlugin::~PythonPlugin() {
helpers::GILAcquirer _;
plugin_ = {};
}
void PythonPlugin::initialize() {
helpers::GILAcquirer _;
try {
const StorePtr& store = get_store();
plugin_.attr("initialize")(store);
}
catch (const python::error_already_set& ex) {
LOG4CXX_ERROR(logger, "Error initializing plugin: "
<< helpers::format_python_exception());
}
}
} // api
} // pirulo
| 2,434 | 776 |
// baulk context
#include <version.hpp>
#include <bela/io.hpp>
#include <baulk/vfs.hpp>
#include <baulk/json_utils.hpp>
#include <baulk/fs.hpp>
#include "baulk.hpp"
namespace baulk {
namespace baulk_internal {
inline std::wstring path_expand(std::wstring_view p) {
if (p.find(L'$') != std::wstring_view::npos) {
return bela::env::PathExpand(p);
}
return bela::WindowsExpandEnv(p);
}
inline std::wstring default_locale_name() {
std::wstring s;
s.resize(64);
if (auto n = GetUserDefaultLocaleName(s.data(), 64); n != 0 && n < 64) {
s.resize(n);
return s;
}
return L"";
}
// https://github.com/baulk/bucket/commits/master.atom
constexpr std::wstring_view DefaultBucket = L"https://github.com/baulk/bucket";
} // namespace baulk_internal
class Context {
public:
Context(const Context &) = delete;
Context &operator=(const Context &) = delete;
static Context &Instance() {
static Context inst;
return inst;
}
bool Initialize(std::wstring_view profile_, bela::error_code &ec);
bool InitializeExecutor(bela::error_code &ec);
bool IsFrozenedPackage(std::wstring_view pkgName) const {
return std::find(pkgs.begin(), pkgs.end(), pkgName) != pkgs.end();
}
std::wstring_view LocaleName() const { return localeName; }
std::wstring_view Profile() const { return profile; }
auto &LoadedBuckets() { return buckets; }
auto &LinkExecutor() { return executor; }
private:
bool initializeInternal(const std::wstring &profile_, bela::error_code &ec);
Context() = default;
std::wstring localeName; // mirrors
std::wstring profile;
Buckets buckets;
std::vector<std::wstring> pkgs;
compiler::Executor executor;
};
constexpr std::wstring_view default_content = LR"({
"bucket": [
{
"description": "Baulk official bucket",
"name": "baulk",
"url": "https://github.com/baulk/bucket",
"weights": 100
}
],
"freeze": [],
"channel": "insider"
})";
bool Context::initializeInternal(const std::wstring &profile_, bela::error_code &ec) {
profile = profile_;
DbgPrint(L"Baulk use profile '%s'", profile);
auto jo = baulk::json::parse_file(profile, ec);
if (!jo) {
buckets.emplace_back(L"Baulk default bucket", L"Baulk", baulk_internal::DefaultBucket);
bela::FPrintF(stderr, L"baulk: \x1b[31m%s\x1b[0m\nprofile path %s\n", ec, profile_);
if (ec.code == ERROR_FILE_NOT_FOUND) {
baulk::fs::MakeParentDirectories(profile, ec);
bela::io::WriteText(default_content, profile, ec);
}
return true;
}
auto jv = jo->view();
localeName = jv.fetch("locale", localeName);
auto svs = jv.subviews("bucket");
for (auto sv : svs) {
buckets.emplace_back(
sv.fetch("description"), sv.fetch("name"), sv.fetch("url"), sv.fetch_as_integer("weights", 100),
static_cast<BucketObserveMode>(sv.fetch_as_integer("mode", static_cast<int>(BucketObserveMode::Github))),
static_cast<BucketVariant>(sv.fetch_as_integer("variant", static_cast<int>(BucketVariant::Native))));
if (IsDebugMode) {
auto bk = buckets.back();
DbgPrint(L"Add bucket '%s': %s", bk.name, bk.description);
DbgPrint(L" url: %s", bk.url);
DbgPrint(L" mode: %s", BucketObserveModeName(bk.mode));
DbgPrint(L" variant: %s", BucketVariantName(bk.variant));
}
}
if (jv.fetch_strings_checked("freeze", pkgs) && !pkgs.empty() && IsDebugMode) {
for (const auto &p : pkgs) {
DbgPrint(L"Freeze package %s", p);
}
}
return true;
}
bool Context::Initialize(std::wstring_view profile_, bela::error_code &ec) {
if (!baulk::vfs::InitializePathFs(ec)) {
return false;
}
localeName = baulk_internal::default_locale_name();
if (IsDebugMode) {
DbgPrint(L"Baulk %s [%s] time: %s", BAULK_VERSION, vfs::AppMode(), BAULK_BUILD_TIME);
DbgPrint(L"Baulk Location '%s'", vfs::AppLocation());
DbgPrint(L"Baulk baulk.exe '%s'", vfs::AppLocationPath(L"baulk.exe"));
DbgPrint(L"Baulk BasePath '%s'", vfs::AppBasePath());
DbgPrint(L"Baulk AppData '%s'", vfs::AppData());
DbgPrint(L"Baulk etc '%s'", vfs::AppEtc());
DbgPrint(L"Baulk AppTemp '%s'", vfs::AppTemp());
DbgPrint(L"Baulk AppPackages '%s'", vfs::AppPackages());
DbgPrint(L"Baulk AppLocks '%s'", vfs::AppLocks());
DbgPrint(L"Baulk AppBuckets '%s'", vfs::AppBuckets());
DbgPrint(L"Baulk AppLinks '%s'", vfs::AppLinks());
DbgPrint(L"Baulk Locale Name '%s'", localeName);
}
if (profile_.empty()) {
return initializeInternal(baulk::vfs::AppDefaultProfile(), ec);
}
return initializeInternal(baulk_internal::path_expand(profile_), ec);
}
bool Context::InitializeExecutor(bela::error_code &ec) { return executor.Initialize(ec); }
// global functions
bool InitializeContext(std::wstring_view profile, bela::error_code &ec) {
return Context::Instance().Initialize(profile, ec);
}
bool InitializeExecutor(bela::error_code &ec) { return Context::Instance().InitializeExecutor(ec); }
std::wstring_view LocaleName() { return Context::Instance().LocaleName(); }
std::wstring_view Profile() { return Context::Instance().Profile(); }
Buckets &LoadedBuckets() { return Context::Instance().LoadedBuckets(); }
compiler::Executor &LinkExecutor() { return Context::Instance().LinkExecutor(); }
bool IsFrozenedPackage(std::wstring_view pkgName) { return Context::Instance().IsFrozenedPackage(pkgName); }
int BucketWeights(std::wstring_view bucket) {
for (const auto &bucket_ : Context::Instance().LoadedBuckets()) {
if (bela::EqualsIgnoreCase(bucket_.name, bucket)) {
return bucket_.weights;
}
}
return 0;
}
} // namespace baulk | 5,686 | 2,046 |
#include "padding.hpp"
vector<vector<float> > Padding(vector<vector<float> > mat, int pad){
for (int j = 0;j<mat.size();j++){
vector<float> row = mat.at(j);
for (int i = 0; i<pad;i++){
row.push_back(0);
row.emplace(row.begin(),0);
}
mat[j] = row;
}
int new_row_length = mat.size() + 2 * pad;
vector<float> zero_row(new_row_length);
for (int i = 0;i<pad;i++){
mat.push_back(zero_row);
mat.emplace(mat.begin(),zero_row);
}
return mat;
} | 534 | 205 |
#pragma once
#define CPPHTTPLIB_OPENSSL_SUPPORT
#include <functional>
#include <api/HttpClient.hpp>
#include <api/HttpRequest.hpp>
#include <api/ExecutionContext.hpp>
#include <spdlog/logger.h>
#include <httplib.h>
namespace ledger {
namespace core {
namespace test {
class CppHttpLibClient : public core::api::HttpClient {
public:
CppHttpLibClient(const std::shared_ptr<core::api::ExecutionContext>& context) :
_context(context), _logger(nullptr), _generateCacheFile(false)
{};
void execute(const std::shared_ptr<core::api::HttpRequest> &request) override;
void setLogger(const std::shared_ptr<spdlog::logger>& logger) {
_logger = logger;
}
void setGenerateCacheFile(bool generateCacheFile) {
_generateCacheFile = generateCacheFile;
}
private:
std::shared_ptr<core::api::ExecutionContext> _context;
std::shared_ptr<spdlog::logger> _logger;
bool _generateCacheFile;
};
}
}
} | 1,191 | 322 |
#include "Application.h"
int main()
{
Application& app = Application::Instance();
app.Init();
app.Loop();
return 0;
} | 127 | 47 |
// Copyright 2019-2022 Cambridge Quantum Computing
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/////////////////////////////////////////////////////
// ALL METHODS TO PERFORM COMPLEX CIRCUIT MANIPULATION//
/////////////////////////////////////////////////////
#include <memory>
#include "Circuit.hpp"
#include "Gate/Gate.hpp"
#include "Ops/ClassicalOps.hpp"
#include "Utils/TketLog.hpp"
#include "Utils/UnitID.hpp"
namespace tket {
vertex_map_t Circuit::copy_graph(
const Circuit& c2, BoundaryMerge boundary_merge,
OpGroupTransfer opgroup_transfer) {
switch (opgroup_transfer) {
case OpGroupTransfer::Preserve:
// Fail if any collisions.
for (const auto& opgroupsig : c2.opgroupsigs) {
if (opgroupsigs.find(opgroupsig.first) != opgroupsigs.end()) {
throw CircuitInvalidity("Name collision in inserted circuit");
}
}
// Add inserted opgroups to circuit.
opgroupsigs.insert(c2.opgroupsigs.begin(), c2.opgroupsigs.end());
break;
case OpGroupTransfer::Disallow:
// Fail if any opgroups.
if (!c2.opgroupsigs.empty()) {
throw CircuitInvalidity("Named op groups in inserted circuit");
}
break;
case OpGroupTransfer::Merge:
// Fail if any mismatched signatures
for (const auto& opgroupsig : c2.opgroupsigs) {
if (opgroupsigs.find(opgroupsig.first) != opgroupsigs.end()) {
if (opgroupsigs[opgroupsig.first] != opgroupsig.second) {
throw CircuitInvalidity(
"Name signature mismatch in inserted circuit");
}
}
}
// Add inserted opgroups to circuit.
opgroupsigs.insert(c2.opgroupsigs.begin(), c2.opgroupsigs.end());
break;
default:
TKET_ASSERT(opgroup_transfer == OpGroupTransfer::Remove);
// Ignore inserted opgroups
break;
}
vertex_map_t isomap;
if (&c2 == this) {
throw Unsupported(
"Circuit Cannot currently copy itself using this method. Use * "
"instead\n");
}
BGL_FORALL_VERTICES(v, c2.dag, DAG) {
Vertex v0 = boost::add_vertex(this->dag);
this->dag[v0].op = c2.get_Op_ptr_from_Vertex(v);
if (opgroup_transfer == OpGroupTransfer::Preserve ||
opgroup_transfer == OpGroupTransfer::Merge) {
this->dag[v0].opgroup = c2.get_opgroup_from_Vertex(v);
}
isomap.insert({v, v0});
}
BGL_FORALL_VERTICES(v, c2.dag, DAG) {
EdgeVec edges = c2.get_in_edges(v);
Vertex target_v = isomap.find(v)->second;
for (EdgeVec::iterator e1 = edges.begin(); e1 != edges.end(); ++e1) {
Vertex old_source_v = c2.source(*e1);
Vertex source_v = isomap.find(old_source_v)->second;
add_edge(
{source_v, get_source_port(*e1)}, {target_v, get_target_port(*e1)},
c2.dag[*e1].type);
}
}
if (boundary_merge == BoundaryMerge::Yes) {
for (const BoundaryElement& el : c2.boundary.get<TagID>()) {
std::string reg_name = el.id_.reg_name();
register_info_t reg_type = el.reg_info();
opt_reg_info_t reg_found = get_reg_info(reg_name);
if (reg_found) {
if (reg_found.value() != reg_type) {
throw Unsupported(
"Cannot merge circuits with different types for "
"register with name: " +
reg_name);
}
boundary_t::iterator unit_found = boundary.get<TagID>().find(el.id_);
if (unit_found != boundary.get<TagID>().end()) {
throw Unsupported(
"Cannot merge circuits as both contain unit: " + el.id_.repr());
}
}
Vertex new_in = isomap[el.in_];
Vertex new_out = isomap[el.out_];
boundary.insert({el.id_, new_in, new_out});
}
}
return isomap;
}
// given two circuits, adds second circuit to first circuit object in parallel
Circuit operator*(const Circuit& c1, const Circuit& c2) {
// preliminary method to add circuit objects together
Circuit new_circ;
new_circ.copy_graph(c1);
new_circ.copy_graph(c2);
new_circ.add_phase(c1.get_phase() + c2.get_phase());
return new_circ;
}
void Circuit::append(const Circuit& c2) { append_with_map(c2, {}); }
// qm is from the units on the second (appended) circuit to the units on the
// first (this) circuit
void Circuit::append_with_map(const Circuit& c2, const unit_map_t& qm) {
Circuit copy = c2;
copy.rename_units(qm);
// Check what we need to do at the joins:
// Output --- Input ==> -------------
// Output --- Create ==> --- Reset ---
// Discard --- Input ==> [not allowed]
// Discard --- Create ==> --- Reset ---
qubit_vector_t qbs = copy.all_qubits();
std::set<Qubit> qbs_set(qbs.begin(), qbs.end());
std::set<Qubit> reset_qbs;
for (auto qb : all_qubits()) {
if (qbs_set.find(qb) != qbs_set.end()) {
if (copy.is_created(qb)) {
reset_qbs.insert(qb);
} else if (is_discarded(qb)) {
throw CircuitInvalidity("Cannot append input qubit to discarded qubit");
}
}
}
// Copy c2 into c1 but do not merge boundaries
vertex_map_t vm = copy_graph(copy, BoundaryMerge::No);
const Op_ptr noop = get_op_ptr(OpType::noop);
// Connect each matching qubit and bit, merging remainder
for (const BoundaryElement& el : copy.boundary.get<TagID>()) {
std::string reg_name = el.reg_name();
register_info_t reg_type = el.reg_info();
opt_reg_info_t reg_found = get_reg_info(reg_name);
if (reg_found) {
if (reg_found.value() != reg_type) {
throw Unsupported(
"Cannot append circuits with different types for "
"register with name: " +
reg_name);
}
boundary_t::iterator unit_found = boundary.get<TagID>().find(el.id_);
if (unit_found != boundary.get<TagID>().end()) {
Vertex out = unit_found->out_;
Vertex in = vm[el.in_];
// Update map
BoundaryElement new_elem = *unit_found;
new_elem.out_ = vm[el.out_];
boundary.replace(unit_found, new_elem);
// Tie together
if (reg_type.first == UnitType::Qubit)
add_edge({out, 0}, {in, 0}, EdgeType::Quantum);
else
add_edge({out, 0}, {in, 0}, EdgeType::Classical);
dag[out].op = noop;
dag[in].op = noop;
remove_vertex(out, GraphRewiring::Yes, VertexDeletion::Yes);
if (el.type() != UnitType::Qubit ||
reset_qbs.find(Qubit(el.id_)) == reset_qbs.end()) {
remove_vertex(in, GraphRewiring::Yes, VertexDeletion::Yes);
} else {
dag[in].op = std::make_shared<const Gate>(OpType::Reset);
}
} else {
Vertex new_in = vm[el.in_];
Vertex new_out = vm[el.out_];
boundary.insert({el.id_, new_in, new_out});
}
} else {
Vertex new_in = vm[el.in_];
Vertex new_out = vm[el.out_];
boundary.insert({el.id_, new_in, new_out});
}
}
add_phase(c2.get_phase());
}
void Circuit::append_qubits(
const Circuit& c2, const std::vector<unsigned>& qubits,
const std::vector<unsigned>& bits) {
unit_map_t qm;
for (unsigned i = 0; i < qubits.size(); i++) {
qm.insert({Qubit(i), Qubit(qubits[i])});
}
for (unsigned i = 0; i < bits.size(); i++) {
qm.insert({Bit(i), Bit(bits[i])});
}
append_with_map(c2, qm);
}
// given two circuits, adds second circuit to first sequentially by tying qubits
// together and returns a copy of this (to prevent destruction of initial
// circuits)
Circuit operator>>(const Circuit& ci1, const Circuit& ci2) {
Circuit new_circ = ci1;
new_circ.append(ci2);
return new_circ;
}
// Important substitute method. Requires knowledge of the boundary to insert
// into, and the vertices inside which are to be removed when substitution is
// performed. Gives the option to isolate the removed vertices but not delete
// them.
void Circuit::substitute(
const Circuit& to_insert, const Subcircuit& to_replace,
VertexDeletion vertex_deletion, OpGroupTransfer opgroup_transfer) {
if (!to_insert.is_simple()) throw SimpleOnly();
if (to_insert.n_qubits() != to_replace.q_in_hole.size() ||
to_insert.n_bits() != to_replace.c_in_hole.size())
throw CircuitInvalidity("Subcircuit boundary mismatch to hole");
vertex_map_t vm = copy_graph(to_insert, BoundaryMerge::No, opgroup_transfer);
VertexList bin;
EdgeSet ebin; // Needs to be a set since subcircuit to replace could be
// trivial, essentially rewiring on a cut
std::map<Edge, Vertex> c_out_map;
const Op_ptr noop = get_op_ptr(OpType::noop);
for (unsigned i = 0; i < to_replace.q_in_hole.size(); i++) {
Edge edge = to_replace.q_in_hole[i];
Vertex pred_v = source(edge);
port_t port1 = get_source_port(edge);
ebin.insert(edge);
Vertex inp = vm[to_insert.get_in(Qubit(i))];
add_edge({pred_v, port1}, {inp, 0}, EdgeType::Quantum);
dag[inp].op = noop;
bin.push_back(inp);
}
for (unsigned i = 0; i < to_replace.q_out_hole.size(); i++) {
Edge edge = to_replace.q_out_hole[i];
Vertex succ_v = target(edge);
port_t port2 = get_target_port(edge);
ebin.insert(edge);
Vertex outp = vm[to_insert.get_out(Qubit(i))];
add_edge({outp, 0}, {succ_v, port2}, EdgeType::Quantum);
dag[outp].op = noop;
bin.push_back(outp);
}
for (unsigned i = 0; i < to_replace.c_in_hole.size(); i++) {
Edge edge = to_replace.c_in_hole[i];
Vertex pred_v = source(edge);
port_t port1 = get_source_port(edge);
ebin.insert(edge);
Vertex inp = vm[to_insert.get_in(Bit(i))];
add_edge({pred_v, port1}, {inp, 0}, EdgeType::Classical);
dag[inp].op = noop;
bin.push_back(inp);
}
for (unsigned i = 0; i < to_replace.c_out_hole.size(); i++) {
Edge edge = to_replace.c_out_hole[i];
Vertex succ_v = target(edge);
port_t port2 = get_target_port(edge);
ebin.insert(edge);
Vertex outp = vm[to_insert.get_out(Bit(i))];
add_edge({outp, 0}, {succ_v, port2}, EdgeType::Classical);
dag[outp].op = noop;
bin.push_back(outp);
c_out_map.insert({edge, outp});
}
for (const Edge& e : to_replace.b_future) {
Edge c_out = get_nth_out_edge(source(e), get_source_port(e));
Vertex outp = c_out_map[c_out];
add_edge({outp, 0}, {target(e), get_target_port(e)}, EdgeType::Boolean);
ebin.insert(e);
}
for (const Edge& e : ebin) {
remove_edge(e);
}
// automatically rewire these canned vertices
remove_vertices(bin, GraphRewiring::Yes, VertexDeletion::Yes);
remove_vertices(to_replace.verts, GraphRewiring::No, vertex_deletion);
add_phase(to_insert.get_phase());
}
void Circuit::substitute(
const Circuit& to_insert, const Vertex& to_replace,
VertexDeletion vertex_deletion, OpGroupTransfer opgroup_transfer) {
Subcircuit sub = {
get_in_edges_of_type(to_replace, EdgeType::Quantum),
get_out_edges_of_type(to_replace, EdgeType::Quantum),
get_in_edges_of_type(to_replace, EdgeType::Classical),
get_out_edges_of_type(to_replace, EdgeType::Classical),
get_out_edges_of_type(to_replace, EdgeType::Boolean),
{to_replace}};
substitute(to_insert, sub, vertex_deletion, opgroup_transfer);
}
void Circuit::substitute_conditional(
Circuit to_insert, const Vertex& to_replace, VertexDeletion vertex_deletion,
OpGroupTransfer opgroup_transfer) {
Op_ptr op = get_Op_ptr_from_Vertex(to_replace);
if (op->get_type() != OpType::Conditional)
throw CircuitInvalidity(
"substitute_conditional called with an unconditional gate");
Subcircuit sub = {
get_in_edges_of_type(to_replace, EdgeType::Quantum),
get_out_edges_of_type(to_replace, EdgeType::Quantum),
get_in_edges_of_type(to_replace, EdgeType::Classical),
get_out_edges_of_type(to_replace, EdgeType::Classical),
get_out_edges_of_type(to_replace, EdgeType::Boolean),
{to_replace}};
const Conditional& cond = static_cast<const Conditional&>(*op);
unsigned width = cond.get_width();
// Conditions are first few args, so increase index of all others
bit_map_t rename_map;
for (unsigned i = 0; i < to_insert.n_bits(); ++i) {
rename_map[Bit(i)] = Bit(i + width);
}
to_insert.rename_units(rename_map);
// Extend subcircuit hole with space for condition bits
bit_vector_t cond_bits(width);
EdgeVec cond_sources;
for (unsigned i = 0; i < width; ++i) {
cond_bits[i] = Bit(i);
Edge read_in = get_nth_in_edge(to_replace, i);
Edge source_write =
get_nth_out_edge(source(read_in), get_source_port(read_in));
cond_sources.push_back(source_write);
}
sub.c_in_hole.insert(
sub.c_in_hole.begin(), cond_sources.begin(), cond_sources.end());
sub.c_out_hole.insert(
sub.c_out_hole.begin(), cond_sources.begin(), cond_sources.end());
to_insert = to_insert.conditional_circuit(cond_bits, cond.get_value());
substitute(to_insert, sub, vertex_deletion, opgroup_transfer);
}
// given the edges to be broken and new
// circuit, implants circuit into old circuit
void Circuit::cut_insert(
const Circuit& incirc, const EdgeVec& q_preds, const EdgeVec& c_preds,
const EdgeVec& b_future) {
Subcircuit sub = {q_preds, q_preds, c_preds, c_preds, b_future};
substitute(incirc, sub, VertexDeletion::No);
}
void Circuit::replace_SWAPs() {
VertexList bin;
BGL_FORALL_VERTICES(v, dag, DAG) {
if (get_Op_ptr_from_Vertex(v)->get_type() == OpType::SWAP) {
Vertex swap = v;
EdgeVec outs = get_all_out_edges(v);
Edge out1 = outs[0];
dag[out1].ports.first = 1;
Edge out2 = outs[1];
dag[out2].ports.first = 0;
remove_vertex(swap, GraphRewiring::Yes, VertexDeletion::No);
bin.push_back(swap);
}
}
remove_vertices(bin, GraphRewiring::No, VertexDeletion::Yes);
}
void Circuit::replace_implicit_wire_swap(
const Qubit first, const Qubit second) {
add_op<UnitID>(OpType::CX, {first, second});
add_op<UnitID>(OpType::CX, {second, first});
Vertex cxvertex = add_op<UnitID>(OpType::CX, {first, second});
EdgeVec outs = get_all_out_edges(cxvertex);
Edge out1 = outs[0];
dag[out1].ports.first = 1;
Edge out2 = outs[1];
dag[out2].ports.first = 0;
}
// helper functions for the dagger and transpose
void Circuit::_handle_boundaries(Circuit& circ, vertex_map_t& vmap) const {
// Handle boundaries
for (const BoundaryElement& el : this->boundary.get<TagID>()) {
Vertex new_in;
Vertex new_out;
if (el.id_.type() == UnitType::Bit) {
tket_log()->warn(
"The circuit contains classical data for which the dagger/transpose "
"might not be defined.");
new_in = circ.add_vertex(OpType::ClInput);
new_out = circ.add_vertex(OpType::ClOutput);
} else {
new_in = circ.add_vertex(OpType::Input);
new_out = circ.add_vertex(OpType::Output);
}
Vertex old_in = el.in_;
Vertex old_out = el.out_;
vmap[old_in] = new_out;
vmap[old_out] = new_in;
circ.boundary.insert({el.id_, new_in, new_out});
}
}
void Circuit::_handle_interior(
Circuit& circ, vertex_map_t& vmap, V_iterator& vi, V_iterator& vend,
ReverseType reverse_op) const {
// Handle interior
for (std::tie(vi, vend) = boost::vertices(this->dag); vi != vend; vi++) {
const Op_ptr op = get_Op_ptr_from_Vertex(*vi);
OpDesc desc = op->get_desc();
if (is_boundary_q_type(desc.type())) {
continue;
} else if ((desc.is_gate() || desc.is_box()) && !desc.is_oneway()) {
Op_ptr op_type_ptr;
switch (reverse_op) {
case ReverseType::dagger: {
op_type_ptr = op->dagger();
break;
}
case ReverseType::transpose: {
op_type_ptr = op->transpose();
break;
}
default: {
throw std::logic_error(
"Error in the definition of the dagger or transpose.");
}
}
Vertex v = circ.add_vertex(op_type_ptr);
vmap[*vi] = v;
} else {
throw CircuitInvalidity(
"Cannot dagger or transpose op: " + op->get_name());
}
}
}
void Circuit::_handle_edges(
Circuit& circ, vertex_map_t& vmap, E_iterator& ei, E_iterator& eend) const {
for (std::tie(ei, eend) = boost::edges(this->dag); ei != eend; ei++) {
Vertex s = source(*ei);
port_t sp = get_source_port(*ei);
Vertex t = target(*ei);
port_t tp = get_target_port(*ei);
circ.add_edge({vmap[t], tp}, {vmap[s], sp}, get_edgetype(*ei));
}
}
// returns Hermitian conjugate of circuit, ie its inverse
Circuit Circuit::dagger() const {
Circuit c;
vertex_map_t vmap;
_handle_boundaries(c, vmap);
V_iterator vi, vend;
ReverseType dagger = ReverseType::dagger;
_handle_interior(c, vmap, vi, vend, dagger);
E_iterator ei, eend;
_handle_edges(c, vmap, ei, eend);
c.add_phase(-get_phase());
return c;
}
// returns transpose of circuit
Circuit Circuit::transpose() const {
Circuit c;
vertex_map_t vmap;
_handle_boundaries(c, vmap);
V_iterator vi, vend;
ReverseType transpose = ReverseType::transpose;
_handle_interior(c, vmap, vi, vend, transpose);
E_iterator ei, eend;
_handle_edges(c, vmap, ei, eend);
c.add_phase(get_phase());
return c;
}
bool Circuit::substitute_all(const Circuit& to_insert, const Op_ptr op) {
if (!to_insert.is_simple()) throw SimpleOnly();
if (op->n_qubits() != to_insert.n_qubits())
throw CircuitInvalidity(
"Cannot substitute all on mismatching arity between Vertex "
"and inserted Circuit");
VertexVec to_replace;
VertexVec conditional_to_replace;
BGL_FORALL_VERTICES(v, dag, DAG) {
Op_ptr v_op = get_Op_ptr_from_Vertex(v);
if (*v_op == *op)
to_replace.push_back(v);
else if (v_op->get_type() == OpType::Conditional) {
const Conditional& cond = static_cast<const Conditional&>(*v_op);
if (*cond.get_op() == *op) conditional_to_replace.push_back(v);
}
}
for (const Vertex& v : to_replace) {
substitute(to_insert, v, VertexDeletion::Yes);
}
for (const Vertex& v : conditional_to_replace) {
substitute_conditional(to_insert, v, VertexDeletion::Yes);
}
return !(to_replace.empty() && conditional_to_replace.empty());
}
bool Circuit::substitute_named(
const Circuit& to_insert, const std::string opname) {
if (!to_insert.is_simple()) throw SimpleOnly();
// Check that no op group names are in common
for (const auto& opgroupsig : to_insert.opgroupsigs) {
if (opgroupsigs.find(opgroupsig.first) != opgroupsigs.end()) {
throw CircuitInvalidity("Name collision in replacement circuit");
}
}
// Do nothing if opname not present
if (opgroupsigs.find(opname) == opgroupsigs.end()) {
return false;
}
// Check signatures match
op_signature_t sig = opgroupsigs[opname];
unsigned sig_n_q = std::count(sig.begin(), sig.end(), EdgeType::Quantum);
unsigned sig_n_c = std::count(sig.begin(), sig.end(), EdgeType::Classical);
unsigned sig_n_b = std::count(sig.begin(), sig.end(), EdgeType::Boolean);
if (to_insert.n_qubits() != sig_n_q || to_insert.n_bits() != sig_n_c ||
sig_n_b != 0) {
throw CircuitInvalidity("Signature mismatch");
}
VertexVec to_replace;
BGL_FORALL_VERTICES(v, dag, DAG) {
std::optional<std::string> v_opgroup = get_opgroup_from_Vertex(v);
if (v_opgroup && v_opgroup.value() == opname) {
to_replace.push_back(v);
}
}
for (const Vertex& v : to_replace) {
substitute(to_insert, v, VertexDeletion::Yes, OpGroupTransfer::Merge);
}
return !to_replace.empty();
}
bool Circuit::substitute_named(Op_ptr to_insert, const std::string opname) {
// Do nothing if opname not present
if (opgroupsigs.find(opname) == opgroupsigs.end()) {
return false;
}
// Check signatures match
op_signature_t sig = opgroupsigs[opname];
if (to_insert->get_signature() != sig) {
throw CircuitInvalidity("Signature mismatch");
}
VertexVec to_replace;
BGL_FORALL_VERTICES(v, dag, DAG) {
std::optional<std::string> v_opgroup = get_opgroup_from_Vertex(v);
if (v_opgroup && v_opgroup.value() == opname) {
to_replace.push_back(v);
}
}
unsigned sig_n_q = std::count(sig.begin(), sig.end(), EdgeType::Quantum);
unsigned sig_n_c = std::count(sig.begin(), sig.end(), EdgeType::Classical);
Circuit c(sig_n_q, sig_n_c);
unit_vector_t args(sig_n_q + sig_n_c);
for (unsigned i = 0; i < sig_n_q; i++) args[i] = Qubit(i);
for (unsigned i = 0; i < sig_n_c; i++) args[sig_n_q + i] = Bit(i);
c.add_op(to_insert, args, opname);
for (const Vertex& v : to_replace) {
substitute(c, v, VertexDeletion::Yes, OpGroupTransfer::Merge);
}
return !to_replace.empty();
}
Circuit Circuit::conditional_circuit(
const bit_vector_t& bits, unsigned value) const {
if (has_implicit_wireswaps()) {
throw CircuitInvalidity("Cannot add conditions to an implicit wireswap");
}
Circuit cond_circ(all_qubits(), all_bits());
for (const Bit& b : bits) {
if (contains_unit(b)) {
Vertex in = get_in(b);
Vertex out = get_out(b);
if (get_successors_of_type(in, EdgeType::Classical).front() != out) {
throw CircuitInvalidity(
"Cannot add condition. Circuit has non-trivial "
"actions on bit " +
b.repr());
}
} else {
cond_circ.add_bit(b);
}
}
unsigned width = bits.size();
for (const Command& com : *this) {
const Op_ptr op = com.get_op_ptr();
Op_ptr cond_op = std::make_shared<Conditional>(op, width, value);
unit_vector_t args = com.get_args();
args.insert(args.begin(), bits.begin(), bits.end());
cond_circ.add_op(cond_op, args);
}
cond_circ.add_phase(get_phase());
return cond_circ;
}
bool Circuit::substitute_box_vertex(
Vertex& vert, VertexDeletion vertex_deletion) {
Op_ptr op = get_Op_ptr_from_Vertex(vert);
bool conditional = op->get_type() == OpType::Conditional;
if (conditional) {
const Conditional& cond = static_cast<const Conditional&>(*op);
op = cond.get_op();
}
if (!op->get_desc().is_box()) return false;
const Box& b = static_cast<const Box&>(*op);
Circuit replacement = *b.to_circuit();
if (conditional) {
substitute_conditional(
replacement, vert, vertex_deletion, OpGroupTransfer::Merge);
} else {
substitute(replacement, vert, vertex_deletion, OpGroupTransfer::Merge);
}
return true;
}
bool Circuit::decompose_boxes() {
bool success = false;
VertexList bin;
BGL_FORALL_VERTICES(v, dag, DAG) {
if (substitute_box_vertex(v, VertexDeletion::No)) {
bin.push_back(v);
success = true;
}
}
remove_vertices(bin, GraphRewiring::No, VertexDeletion::Yes);
return success;
}
void Circuit::decompose_boxes_recursively() {
while (decompose_boxes()) {
}
}
std::map<Bit, bool> Circuit::classical_eval(
const std::map<Bit, bool>& values) const {
std::map<Bit, bool> v(values);
for (CommandIterator it = begin(); it != end(); ++it) {
Op_ptr op = it->get_op_ptr();
OpType optype = op->get_type();
if (!is_classical_type(optype)) {
throw CircuitInvalidity("Non-classical operation");
}
std::shared_ptr<const ClassicalEvalOp> cop =
std::dynamic_pointer_cast<const ClassicalEvalOp>(op);
unit_vector_t args = it->get_args();
unsigned n_args = args.size();
switch (optype) {
case OpType::ClassicalTransform: {
std::vector<bool> input(n_args);
for (unsigned i = 0; i < n_args; i++) {
input[i] = v[Bit(args[i])];
}
std::vector<bool> output = cop->eval(input);
TKET_ASSERT(output.size() == n_args);
for (unsigned i = 0; i < n_args; i++) {
v[Bit(args[i])] = output[i];
}
break;
}
case OpType::SetBits: {
std::vector<bool> output = cop->eval({});
TKET_ASSERT(output.size() == n_args);
for (unsigned i = 0; i < n_args; i++) {
v[Bit(args[i])] = output[i];
}
break;
}
default:
throw CircuitInvalidity("Unexpected operation in circuit");
}
}
return v;
}
} // namespace tket
| 24,531 | 8,884 |
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "log_controller.h"
#include <cstring>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <securec.h>
#include <stdio.h>
#include <regex>
#include "hilog/log.h"
#include "hilog_common.h"
#include "hilogtool_msg.h"
#include "seq_packet_socket_client.h"
#include "properties.h"
#include "log_display.h"
namespace OHOS {
namespace HiviewDFX {
using namespace std;
const int LOG_PERSIST_FILE_SIZE = 4 * ONE_MB;
const int LOG_PERSIST_FILE_NUM = 10;
const uint32_t DEFAULT_JOBID = 1;
void SetMsgHead(MessageHeader* msgHeader, const uint8_t msgCmd, const uint16_t msgLen)
{
if (!msgHeader) {
return;
}
msgHeader->version = 0;
msgHeader->msgType = msgCmd;
msgHeader->msgLen = msgLen;
}
void Split(const std::string& src, const std::string& separator, std::vector<std::string>& dest)
{
string str = src;
string substring;
string::size_type start = 0;
string::size_type index;
dest.clear();
index = str.find_first_of(separator, start);
if (index == string::npos) {
dest.push_back(str);
return;
}
do {
substring = str.substr(start, index - start);
dest.push_back(substring);
start = index + separator.size();
index = str.find(separator, start);
if (start == string::npos) {
break;
}
} while (index != string::npos);
substring = str.substr(start);
dest.emplace_back(substring);
}
uint16_t GetLogType(const string& logTypeStr)
{
uint16_t logType;
if (logTypeStr == "init") {
logType = LOG_INIT;
} else if (logTypeStr == "core") {
logType = LOG_CORE;
} else if (logTypeStr == "app") {
logType = LOG_APP;
} else {
return 0xffff;
}
return logType;
}
uint64_t GetBuffSize(const string& buffSizeStr)
{
uint64_t index = buffSizeStr.size() - 1;
uint64_t buffSize;
std::regex reg("[0-9]+[bBkKmMgGtT]?");
if (!std::regex_match(buffSizeStr, reg)) {
std::cout << ParseErrorCode(ERR_BUFF_SIZE_INVALID) << std::endl;
exit(-1);
}
if (buffSizeStr[index] == 'b' || buffSizeStr[index] == 'B') {
buffSize = stol(buffSizeStr.substr(0, index));
} else if (buffSizeStr[index] == 'k' || buffSizeStr[index] == 'K') {
buffSize = stol(buffSizeStr.substr(0, index)) * ONE_KB;
} else if (buffSizeStr[index] == 'm' || buffSizeStr[index] == 'M') {
buffSize = stol(buffSizeStr.substr(0, index)) * ONE_MB;
} else if (buffSizeStr[index] == 'g' || buffSizeStr[index] == 'G') {
buffSize = stol(buffSizeStr.substr(0, index)) * ONE_GB;
} else if (buffSizeStr[index] == 't' || buffSizeStr[index] == 'T') {
buffSize = stol(buffSizeStr.substr(0, index)) * ONE_TB;
} else {
buffSize = stol(buffSizeStr.substr(0, index + 1));
}
return buffSize;
}
uint16_t GetCompressAlg(const std::string& pressAlg)
{
if (pressAlg == "none") {
return COMPRESS_TYPE_NONE;
} else if (pressAlg == "zlib") {
return COMPRESS_TYPE_ZLIB;
} else if (pressAlg == "zstd") {
return COMPRESS_TYPE_ZSTD;
}
return COMPRESS_TYPE_ZLIB;
}
uint16_t GetLogLevel(const std::string& logLevelStr, std::string& logLevel)
{
if (logLevelStr == "debug" || logLevelStr == "DEBUG" || logLevelStr == "d" || logLevelStr == "D") {
logLevel = "D";
return LOG_DEBUG;
} else if (logLevelStr == "info" || logLevelStr == "INFO" || logLevelStr == "i" || logLevelStr == "I") {
logLevel = "I";
return LOG_INFO;
} else if (logLevelStr == "warn" || logLevelStr == "WARN" || logLevelStr == "w" || logLevelStr == "W") {
logLevel = "W";
return LOG_WARN;
} else if (logLevelStr == "error" || logLevelStr == "ERROR" || logLevelStr == "e" || logLevelStr == "E") {
logLevel = "E";
return LOG_ERROR;
} else if (logLevelStr == "fatal" || logLevelStr == "FATAL" || logLevelStr == "f" || logLevelStr == "F") {
logLevel = "F";
return LOG_FATAL;
}
return 0xffff;
}
string SetDefaultLogType(const std::string& logTypeStr)
{
string logType;
if (logTypeStr == "") {
logType = "core app";
} else if (logTypeStr == "all") {
logType = "core app init";
} else {
logType = logTypeStr;
}
return logType;
}
void NextRequestOp(SeqPacketSocketClient& controller, uint16_t sendId)
{
NextRequest nextRequest;
memset_s(&nextRequest, sizeof(nextRequest), 0, sizeof(nextRequest));
SetMsgHead(&nextRequest.header, NEXT_REQUEST, sizeof(NextRequest)-sizeof(MessageHeader));
nextRequest.sendId = sendId;
controller.WriteAll((char*)&nextRequest, sizeof(NextRequest));
}
void LogQueryRequestOp(SeqPacketSocketClient& controller, const HilogArgs* context)
{
LogQueryRequest logQueryRequest;
memset_s(&logQueryRequest, sizeof(LogQueryRequest), 0, sizeof(LogQueryRequest));
logQueryRequest.levels = context->levels;
logQueryRequest.types = context->types;
logQueryRequest.nPid = context->nPid;
logQueryRequest.nDomain = context->nDomain;
logQueryRequest.nTag = context->nTag;
for (int i = 0; i < context->nPid; i++) {
std::istringstream(context->pids[i]) >> std::dec >> logQueryRequest.pids[i];
}
for (int i = 0; i < context->nDomain; i++) {
std::istringstream(context->domains[i]) >> std::hex >> logQueryRequest.domains[i];
}
for (int i = 0; i < context->nTag; i++) {
if (strncpy_s(logQueryRequest.tags[i], MAX_TAG_LEN,
context->tags[i].c_str(), context->tags[i].length())) {
continue;
}
}
logQueryRequest.noLevels = context->noLevels;
logQueryRequest.noTypes = context->noTypes;
logQueryRequest.nNoPid = context->nNoPid;
logQueryRequest.nNoDomain = context->nNoDomain;
logQueryRequest.nNoTag = context->nNoTag;
for (int i = 0; i < context->nNoPid; i++) {
std::istringstream(context->noPids[i]) >> std::dec >> logQueryRequest.noPids[i];
}
for (int i = 0; i < context->nNoDomain; i++) {
std::istringstream(context->noDomains[i]) >> std::hex >> logQueryRequest.noDomains[i];
}
for (int i = 0; i < context->nNoTag; i++) {
if (strncpy_s(logQueryRequest.noTags[i], MAX_TAG_LEN,
context->noTags[i].c_str(), context->noTags[i].length())) {
continue;
}
}
SetMsgHead(&logQueryRequest.header, LOG_QUERY_REQUEST, sizeof(LogQueryRequest)-sizeof(MessageHeader));
logQueryRequest.header.version = 0;
controller.WriteAll((char*)&logQueryRequest, sizeof(LogQueryRequest));
}
void LogQueryResponseOp(SeqPacketSocketClient& controller, char* recvBuffer, uint32_t bufLen,
HilogArgs* context, HilogShowFormat format)
{
static std::vector<string> tailBuffer;
LogQueryResponse* rsp = reinterpret_cast<LogQueryResponse*>(recvBuffer);
HilogDataMessage* data = &(rsp->data);
if (data->sendId != SENDIDN) {
HilogShowLog(format, data, context, tailBuffer);
}
NextRequestOp(controller, SENDIDA);
while(1) {
memset_s(recvBuffer, bufLen, 0, bufLen);
if (controller.RecvMsg(recvBuffer, bufLen) == 0) {
fprintf(stderr, "Unexpected EOF %s\n", strerror(errno));
exit(1);
return;
}
MessageHeader* msgHeader = &(rsp->header);
if (msgHeader->msgType == NEXT_RESPONSE) {
switch (data->sendId) {
case SENDIDN:
if (context->noBlockMode) {
if (context->tailLines) {
while (context->tailLines-- && !tailBuffer.empty()) {
cout << tailBuffer.back() << endl;
tailBuffer.pop_back();
}
}
NextRequestOp(controller, SENDIDN);
exit(1);
}
break;
case SENDIDA:
HilogShowLog(format, data, context, tailBuffer);
NextRequestOp(controller, SENDIDA);
break;
default:
NextRequestOp(controller, SENDIDA);
break;
}
}
}
}
int32_t BufferSizeOp(SeqPacketSocketClient& controller, uint8_t msgCmd, const std::string& logTypeStr,
const std::string& buffSizeStr)
{
char msgToSend[MSG_MAX_LEN] = {0};
vector<string> vecLogType;
uint32_t logTypeNum;
uint32_t iter;
string logType = SetDefaultLogType(logTypeStr);
Split(logType, " ", vecLogType);
logTypeNum = vecLogType.size();
switch (msgCmd) {
case MC_REQ_BUFFER_SIZE: {
BufferSizeRequest* pBuffSizeReq = reinterpret_cast<BufferSizeRequest*>(msgToSend);
BuffSizeMsg* pBuffSizeMsg = reinterpret_cast<BuffSizeMsg*>(&pBuffSizeReq->buffSizeMsg);
if (logTypeNum * sizeof(BuffSizeMsg) + sizeof(MessageHeader) > MSG_MAX_LEN) {
return RET_FAIL;
}
for (iter = 0; iter < logTypeNum; iter++) {
pBuffSizeMsg->logType = GetLogType(vecLogType[iter]);
if (pBuffSizeMsg->logType == 0xffff) {
cout << ParseErrorCode(ERR_LOG_TYPE_INVALID) << endl;
return RET_FAIL;
}
pBuffSizeMsg++;
}
SetMsgHead(&pBuffSizeReq->msgHeader, msgCmd, sizeof(BuffSizeMsg) * logTypeNum);
controller.WriteAll(msgToSend, sizeof(MessageHeader) + sizeof(BuffSizeMsg) * logTypeNum);
break;
}
case MC_REQ_BUFFER_RESIZE: {
BufferResizeRequest* pBuffResizeReq = reinterpret_cast<BufferResizeRequest*>(msgToSend);
BuffResizeMsg* pBuffResizeMsg = reinterpret_cast<BuffResizeMsg*>(&pBuffResizeReq->buffResizeMsg);
if (logTypeNum * sizeof(BuffResizeMsg) + sizeof(MessageHeader) > MSG_MAX_LEN) {
return RET_FAIL;
}
for (iter = 0; iter < logTypeNum; iter++) {
pBuffResizeMsg->logType = GetLogType(vecLogType[iter]);
if (pBuffResizeMsg->logType == 0xffff) {
cout << ParseErrorCode(ERR_LOG_TYPE_INVALID) << endl;
return RET_FAIL;
}
pBuffResizeMsg->buffSize = GetBuffSize(buffSizeStr);
pBuffResizeMsg++;
}
SetMsgHead(&pBuffResizeReq->msgHeader, msgCmd, sizeof(BuffResizeMsg) * logTypeNum);
controller.WriteAll(msgToSend, sizeof(MessageHeader) + sizeof(BuffResizeMsg) * logTypeNum);
break;
}
default:
break;
}
return RET_SUCCESS;
}
int32_t StatisticInfoOp(SeqPacketSocketClient& controller, uint8_t msgCmd,
const std::string& logTypeStr, const std::string& domainStr)
{
if ((logTypeStr != "" && domainStr != "") || (logTypeStr == "" && domainStr == "")) {
return RET_FAIL;
}
uint16_t logType = GetLogType(logTypeStr);
uint32_t domain;
if (domainStr == "") {
domain = 0xffffffff;
if (logType == 0xffff) {
cout << ParseErrorCode(ERR_LOG_TYPE_INVALID) << endl;
return RET_FAIL;
}
} else {
std::istringstream(domainStr) >> domain;
if (domain == 0 || domain > DOMAIN_MAX_SCOPE) {
cout << ParseErrorCode(ERR_DOMAIN_INVALID) << endl;
return RET_FAIL;
}
}
switch (msgCmd) {
case MC_REQ_STATISTIC_INFO_QUERY:
StatisticInfoQueryRequest staInfoQueryReq;
memset_s(&staInfoQueryReq, sizeof(StatisticInfoQueryRequest), 0, sizeof(StatisticInfoQueryRequest));
staInfoQueryReq.logType = logType;
staInfoQueryReq.domain = domain;
SetMsgHead(&staInfoQueryReq.msgHeader, msgCmd, sizeof(StatisticInfoQueryRequest) - sizeof(MessageHeader));
controller.WriteAll((char*)&staInfoQueryReq, sizeof(StatisticInfoQueryRequest));
break;
case MC_REQ_STATISTIC_INFO_CLEAR:
StatisticInfoClearRequest staInfoClearReq;
memset_s(&staInfoClearReq, sizeof(StatisticInfoClearRequest), 0, sizeof(StatisticInfoClearRequest));
staInfoClearReq.logType = logType;
staInfoClearReq.domain = domain;
SetMsgHead(&staInfoClearReq.msgHeader, msgCmd, sizeof(StatisticInfoClearRequest) - sizeof(MessageHeader));
controller.WriteAll((char*)&staInfoClearReq, sizeof(StatisticInfoClearRequest));
break;
default:
break;
}
return RET_SUCCESS;
}
int32_t LogClearOp(SeqPacketSocketClient& controller, uint8_t msgCmd, const std::string& logTypeStr)
{
char msgToSend[MSG_MAX_LEN] = {0};
vector<string> vecLogType;
uint32_t logTypeNum;
uint32_t iter;
string logType = SetDefaultLogType(logTypeStr);
Split(logType, " ", vecLogType);
logTypeNum = vecLogType.size();
LogClearRequest* pLogClearReq = reinterpret_cast<LogClearRequest*>(msgToSend);
LogClearMsg* pLogClearMsg = reinterpret_cast<LogClearMsg*>(&pLogClearReq->logClearMsg);
if (!pLogClearMsg) {
cout << ParseErrorCode(ERR_MEM_ALLOC_FAIL) << endl;
return RET_FAIL;
}
if (logTypeNum * sizeof(LogClearMsg) + sizeof(MessageHeader) > MSG_MAX_LEN) {
cout << ParseErrorCode(ERR_MSG_LEN_INVALID) << endl;
return RET_FAIL;
}
for (iter = 0; iter < logTypeNum; iter++) {
pLogClearMsg->logType = GetLogType(vecLogType[iter]);
if (pLogClearMsg->logType == 0xffff) {
cout << ParseErrorCode(ERR_LOG_TYPE_INVALID) << endl;
return RET_FAIL;
}
pLogClearMsg++;
}
SetMsgHead(&pLogClearReq->msgHeader, msgCmd, sizeof(LogClearMsg) * logTypeNum);
controller.WriteAll(msgToSend, sizeof(LogClearMsg) * logTypeNum + sizeof(MessageHeader));
return RET_SUCCESS;
}
int32_t LogPersistOp(SeqPacketSocketClient& controller, uint8_t msgCmd, LogPersistParam* logPersistParam)
{
char msgToSend[MSG_MAX_LEN] = {0};
vector<string> vecLogType;
vector<string> vecJobId;
uint32_t logTypeNum;
uint32_t jobIdNum;
uint32_t iter;
int ret = 0;
uint32_t fileSizeDefault = LOG_PERSIST_FILE_SIZE;
uint32_t fileNumDefault = LOG_PERSIST_FILE_NUM;
string logType = SetDefaultLogType(logPersistParam->logTypeStr);
Split(logType, " ", vecLogType);
Split(logPersistParam->jobIdStr, " ", vecJobId);
logTypeNum = vecLogType.size();
jobIdNum = vecJobId.size();
switch (msgCmd) {
case MC_REQ_LOG_PERSIST_START: {
LogPersistStartRequest* pLogPersistStartReq = reinterpret_cast<LogPersistStartRequest*>(msgToSend);
LogPersistStartMsg* pLogPersistStartMsg =
reinterpret_cast<LogPersistStartMsg*>(&pLogPersistStartReq->logPersistStartMsg);
if (sizeof(LogPersistStartRequest) > MSG_MAX_LEN) {
cout << ParseErrorCode(ERR_MSG_LEN_INVALID) << endl;
return RET_FAIL;
}
for (iter = 0; iter < logTypeNum; iter++) {
uint16_t tmpType = GetLogType(vecLogType[iter]);
if (tmpType == 0xffff) {
cout << ParseErrorCode(ERR_LOG_TYPE_INVALID) << endl;
return RET_FAIL;
}
pLogPersistStartMsg->logType = (0b01 << tmpType) | pLogPersistStartMsg->logType;
}
pLogPersistStartMsg->jobId = (logPersistParam->jobIdStr == "") ? DEFAULT_JOBID
: stoi(logPersistParam->jobIdStr);
if (pLogPersistStartMsg->jobId <= 0) {
cout << ParseErrorCode(ERR_LOG_PERSIST_JOBID_INVALID) << endl;
return RET_FAIL;
}
pLogPersistStartMsg->compressAlg = (logPersistParam->compressAlgStr == "") ? COMPRESS_TYPE_ZLIB :
GetCompressAlg(logPersistParam->compressAlgStr);
pLogPersistStartMsg->fileSize = (logPersistParam->fileSizeStr == "") ? fileSizeDefault : GetBuffSize(
logPersistParam->fileSizeStr);
pLogPersistStartMsg->fileNum = (logPersistParam->fileNumStr == "") ? fileNumDefault
: stoi(logPersistParam->fileNumStr);
if (logPersistParam->fileNameStr.size() > FILE_PATH_MAX_LEN) {
cout << ParseErrorCode(ERR_LOG_PERSIST_FILE_NAME_INVALID) << endl;
return RET_FAIL;
}
if (logPersistParam->fileNameStr != " ") {
ret += strcpy_s(pLogPersistStartMsg->filePath, FILE_PATH_MAX_LEN, logPersistParam->fileNameStr.c_str());
}
SetMsgHead(&pLogPersistStartReq->msgHeader, msgCmd, sizeof(LogPersistStartRequest));
controller.WriteAll(msgToSend, sizeof(LogPersistStartRequest));
break;
}
case MC_REQ_LOG_PERSIST_STOP: {
LogPersistStopRequest* pLogPersistStopReq =
reinterpret_cast<LogPersistStopRequest*>(msgToSend);
LogPersistStopMsg* pLogPersistStopMsg =
reinterpret_cast<LogPersistStopMsg*>(&pLogPersistStopReq->logPersistStopMsg);
if (logPersistParam->jobIdStr == "") {
pLogPersistStopMsg->jobId = JOB_ID_ALL;
SetMsgHead(&pLogPersistStopReq->msgHeader, msgCmd, sizeof(LogPersistStopMsg));
controller.WriteAll(msgToSend, sizeof(LogPersistStopMsg) + sizeof(MessageHeader));
break;
}
if (jobIdNum * sizeof(LogPersistStopMsg) + sizeof(MessageHeader) > MSG_MAX_LEN) {
cout << ParseErrorCode(ERR_MSG_LEN_INVALID) << endl;
return RET_FAIL;
}
for (iter = 0; iter < jobIdNum; iter++) {
pLogPersistStopMsg->jobId = stoi(vecJobId[iter]);
pLogPersistStopMsg++;
}
SetMsgHead(&pLogPersistStopReq->msgHeader, msgCmd, sizeof(LogPersistStopMsg) * jobIdNum);
controller.WriteAll(msgToSend, sizeof(LogPersistStopMsg) * jobIdNum + sizeof(MessageHeader));
break;
}
case MC_REQ_LOG_PERSIST_QUERY: {
LogPersistQueryRequest* pLogPersistQueryReq =
reinterpret_cast<LogPersistQueryRequest*>(msgToSend);
LogPersistQueryMsg* pLogPersistQueryMsg =
reinterpret_cast<LogPersistQueryMsg*>(&pLogPersistQueryReq->logPersistQueryMsg);
for (iter = 0; iter < logTypeNum; iter++) {
uint16_t tmpType = GetLogType(vecLogType[iter]);
if (tmpType == 0xffff) {
cout << ParseErrorCode(ERR_LOG_TYPE_INVALID) << endl;
return RET_FAIL;
}
pLogPersistQueryMsg->logType = (0b01 << tmpType) | pLogPersistQueryMsg->logType;
}
SetMsgHead(&pLogPersistQueryReq->msgHeader, msgCmd, sizeof(LogPersistQueryMsg));
controller.WriteAll(msgToSend, sizeof(LogPersistQueryRequest));
break;
}
default:
break;
}
if (ret) {
return RET_FAIL;
}
return RET_SUCCESS;
}
int32_t SetPropertiesOp(SeqPacketSocketClient& controller, uint8_t operationType, SetPropertyParam* propertyParm)
{
vector<string> vecDomain;
vector<string> vecTag;
uint32_t domainNum, tagNum;
uint32_t iter;
string key, value;
Split(propertyParm->domainStr, " ", vecDomain);
Split(propertyParm->tagStr, " ", vecTag);
domainNum = vecDomain.size();
tagNum = vecTag.size();
switch (operationType) {
case OT_PRIVATE_SWITCH:
key = GetPropertyName(PROP_PRIVATE);
if (propertyParm->privateSwitchStr == "on") {
PropertySet(key.c_str(), "true");
cout << "hilog private formatter is enabled" << endl;
} else if (propertyParm->privateSwitchStr == "off") {
PropertySet(key.c_str(), "false");
cout << "hilog private formatter is disabled" << endl;
} else {
cout << ParseErrorCode(ERR_PRIVATE_SWITCH_VALUE_INVALID) << endl;
return RET_FAIL;
}
break;
case OT_LOG_LEVEL:
if (propertyParm->tagStr != "" && propertyParm->domainStr != "") {
return RET_FAIL;
} else if (propertyParm->domainStr != "") { // by domain
std::string keyPre = GetPropertyName(PROP_DOMAIN_LOG_LEVEL);
for (iter = 0; iter < domainNum; iter++) {
key = keyPre + vecDomain[iter];
if (GetLogLevel(propertyParm->logLevelStr, value) == 0xffff) {
continue;
}
PropertySet(key.c_str(), value.c_str());
cout << "domain " << vecDomain[iter] << " level is set to " << propertyParm->logLevelStr << endl;
}
} else if (propertyParm->tagStr != "") { // by tag
std::string keyPre = GetPropertyName(PROP_TAG_LOG_LEVEL);
for (iter = 0; iter < tagNum; iter++) {
key = keyPre + vecTag[iter];
if (GetLogLevel(propertyParm->logLevelStr, value) == 0xffff) {
continue;
}
PropertySet(key.c_str(), value.c_str());
cout << "tag " << vecTag[iter] << " level is set to " << propertyParm->logLevelStr << endl;
}
} else {
key = GetPropertyName(PROP_GLOBAL_LOG_LEVEL);
if (GetLogLevel(propertyParm->logLevelStr, value) == 0xffff) {
return RET_FAIL;
}
PropertySet(key.c_str(), value.c_str());
cout << "global log level is set to " << propertyParm->logLevelStr << endl;
}
break;
case OT_FLOW_SWITCH:
if (propertyParm->flowSwitchStr == "pidon") {
key = GetPropertyName(PROP_PROCESS_FLOWCTRL);
PropertySet(key.c_str(), "true");
cout << "flow control by process is enabled" << endl;
} else if (propertyParm->flowSwitchStr == "pidoff") {
key = GetPropertyName(PROP_PROCESS_FLOWCTRL);
PropertySet(key.c_str(), "false");
cout << "flow control by process is disabled" << endl;
} else if (propertyParm->flowSwitchStr == "domainon") {
key = GetPropertyName(PROP_DOMAIN_FLOWCTRL);
PropertySet(key.c_str(), "true");
cout << "flow control by domain is enabled" << endl;
} else if (propertyParm->flowSwitchStr == "domainoff") {
key = GetPropertyName(PROP_DOMAIN_FLOWCTRL);
PropertySet(key.c_str(), "false");
cout << "flow control by domain is disabled" << endl;
} else {
cout << ParseErrorCode(ERR_FLOWCTRL_SWITCH_VALUE_INVALID) << endl;
return RET_FAIL;
}
break;
default:
break;
}
return RET_SUCCESS;
}
int MultiQuerySplit(const std::string& src, const char& delim, std::vector<std::string>& vecSplit)
{
int srcSize = src.length();
int findPos = 0;
int getPos = 0;
vecSplit.clear();
while (getPos < srcSize) {
findPos = src.find(delim, findPos);
if (-1 == findPos) {
if (getPos < srcSize) {
vecSplit.push_back(src.substr(getPos, srcSize - getPos));
return 0;
}
} else if (findPos == getPos) {
vecSplit.push_back(std::string(""));
} else {
vecSplit.push_back(src.substr(getPos, findPos - getPos));
}
getPos = ++findPos;
if (getPos == srcSize) {
vecSplit.push_back(std::string(""));
return 0;
}
}
return 0;
}
} // namespace HiviewDFX
} // namespace OHOS
| 24,718 | 7,816 |
#include <cstdio>
#include <cstring>
int bound;
bool flag;
char ch[4]={'A','C','G','T'};
int map[128];
inline int min(int a,int b){
return a>b?b:a;
}
inline int max(int a,int b){
return a>b?a:b;
}
struct D{
int k;
char s[10][10];
int cur[10];
int len[10];
int H() {
int n[4]={0};
for(int i=0;i<k;i++){
int tmp[4]={0};
for(int j=cur[i];j<len[i];j++){
tmp[map[s[i][j]]]++;
}
n[0]=max(n[0],tmp[0]);
n[1]=max(n[1],tmp[1]);
n[2]=max(n[2],tmp[2]);
n[3]=max(n[3],tmp[3]);
}
return n[0]+n[1]+n[2]+n[3];
}
}s;
int dfs(int x){
int hv=s.H();
if(x+hv>bound)
return x+hv;
if(hv==0)
return flag=true,x;
int nxt=0x7FFF,tmp;
int old[10];
memcpy(old, s.cur, sizeof(old));
for(int i=0;i<4;i++){
bool flag2=false;
for(int j=0;j<s.k;j++){
if(s.s[j][s.cur[j]]==ch[i]) {
s.cur[j]++;
flag2=true;
}
}
if(!flag2)
continue;
tmp = dfs(x+1);
if(flag)
return tmp;
if(nxt>tmp)
nxt=tmp;
memcpy(s.cur,old,sizeof(old));
}
return nxt;
}
int main() {
map['A']=0;
map['C']=1;
map['G']=2;
map['T']=3;
int N;
scanf("%d",&N);
while(N--){
flag=false;
scanf("%d",&s.k);
for(int i=0;i<s.k;i++){
scanf("%s",s.s[i]);
s.cur[i]=0;
s.len[i]=strlen(s.s[i]);
}
for(bound=s.H();!flag;bound=dfs(0));
printf("%d\n",bound);
}
}
| 1,461 | 734 |
/* Copyright 2015-2021 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
class A
{
public:
A () : a_ (1) {}
int get ();
protected:
int a_;
private:
/* It is important to not /not/ use the nested class definition in A.
This exercises a different path through the code. */
struct Inner1
{
int a_;
Inner1 () : a_ (2) {}
struct Inner2
{
int a_;
Inner2 () : a_ (3) {}
};
};
};
int
A::get ()
{
A::Inner1 i1;
A::Inner1::Inner2 i2;
return i1.a_ + i2.a_; // break here
}
int var = 1234;
int
main ()
{
A a;
return a.get ();
}
| 1,215 | 419 |
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ohos/aafwk/content/intent_filter.h"
#include "string_ex.h"
#include "ohos/aafwk/content/intent.h"
namespace OHOS {
namespace AAFwk {
IntentFilter::IntentFilter()
{}
std::string IntentFilter::GetEntity() const
{
return entity_;
}
void IntentFilter::SetEntity(const std::string &entity)
{
entity_ = entity;
}
void IntentFilter::AddAction(const std::string &action)
{
auto it = std::find(actions_.cbegin(), actions_.cend(), action);
if (it == actions_.cend()) {
actions_.push_back(action);
}
}
int IntentFilter::CountAction() const
{
return actions_.size();
}
std::string IntentFilter::GetAction(int index) const
{
std::string action;
if (index < static_cast<int>(actions_.size())) {
action = actions_[index];
}
return action;
}
void IntentFilter::RemoveAction(const std::string &action)
{
auto it = std::find(actions_.cbegin(), actions_.cend(), action);
if (it != actions_.cend()) {
actions_.erase(it);
}
}
bool IntentFilter::HasAction(const std::string &action) const
{
return std::find(actions_.cbegin(), actions_.cend(), action) != actions_.cend();
}
bool IntentFilter::Marshalling(Parcel &parcel) const
{
// write entity
if (!parcel.WriteString16(Str8ToStr16(entity_))) {
return false;
}
// write actions
std::vector<std::u16string> actionU16;
for (std::vector<std::string>::size_type i = 0; i < actions_.size(); i++) {
actionU16.push_back(Str8ToStr16(actions_[i]));
}
if (!parcel.WriteString16Vector(actionU16)) {
return false;
}
return true;
}
bool IntentFilter::ReadFromParcel(Parcel &parcel)
{
// read entity
entity_ = Str16ToStr8(parcel.ReadString16());
// read actions
std::vector<std::u16string> actionU16;
if (!parcel.ReadString16Vector(&actionU16)) {
return false;
}
actions_.clear();
for (std::vector<std::u16string>::size_type i = 0; i < actionU16.size(); i++) {
actions_.push_back(Str16ToStr8(actionU16[i]));
}
return true;
}
IntentFilter *IntentFilter::Unmarshalling(Parcel &parcel)
{
IntentFilter *filter = new (std::nothrow) IntentFilter();
if (filter && !filter->ReadFromParcel(parcel)) {
delete filter;
filter = nullptr;
}
return filter;
}
bool IntentFilter::MatchAction(const std::string &action) const
{
return HasAction(action);
}
bool IntentFilter::MatchEntity(const std::string &entity) const
{
return entity_ == entity;
}
bool IntentFilter::Match(const Intent &intent) const
{
return MatchAction(intent.GetAction()) && MatchEntity(intent.GetEntity());
}
} // namespace AAFwk
} // namespace OHOS
| 3,308 | 1,093 |
///////////////////////////////////////////////////////////
// MYTREE Linuxvariante
#include <sys/types.h>
#include <dirent.h>
#include <string>
#include <list>
#include <iostream>
#include <algorithm>
using namespace std;
////////////////////////////////////////////
class Visitor
{
public:
Visitor() {};
~Visitor() {};
virtual void visit(class Verzeichnis& v) = 0;
virtual void visit(class Datei& d) = 0;
};
// Kompositstruktur
class Datei // Komponente
{
public:
Datei( const string &n ) : name( n ) {}
virtual ~Datei();
const string & GibName() const { return name; }
virtual void accept(Visitor& visitor)
{
}
protected:
string name;
};
class Verzeichnis : public Datei // Komposite
{
public:
Verzeichnis( const string &n );
~Verzeichnis();
typedef std::list<Datei *> Dateiliste;
Dateiliste liste;
void accept(Visitor& visitor) override;
};
///////////////////////
class RegulaereDatei : public Datei // Leaf
{
public:
RegulaereDatei( const string &n ) : Datei( n ) {}
};
class GeraeteDatei : public Datei // Leaf
{
public:
GeraeteDatei( const string &n ) : Datei( n ) {}
};
class KommunikationsDatei : public Datei // Leaf
{
public:
KommunikationsDatei( const string &n ) : Datei( n ) {}
};
class SonstigeDatei : public Datei // Leaf
{
public:
SonstigeDatei( const string &n ) : Datei( n ) {}
};
////////////////////////////////////////////////////////////////////////////////
Datei::~Datei() {}
Verzeichnis::Verzeichnis( const string &n ) : Datei( n )
{
struct dirent *pde;
DIR *dirp = opendir( n.c_str() );
if( dirp != NULL )
{
while( (pde = readdir( dirp )) != NULL )
{
std::string dname( pde->d_name );
if( dname != "." && dname != ".." )
{
Datei *pd = 0;
switch( pde->d_type )
{
case DT_REG:
pd = new RegulaereDatei( dname );
break;
case DT_DIR:
{
std::string vn( n );
if( vn[vn.size() - 1] != '/' )
vn += "/";
vn += dname;
pd = new Verzeichnis( vn );
}
break;
case DT_FIFO:
case DT_SOCK:
pd = new KommunikationsDatei( dname );
break;
case DT_CHR:
case DT_BLK:
pd = new GeraeteDatei( dname );
break;
case DT_UNKNOWN:
default:
pd = new SonstigeDatei( dname );
break;
}
if( pd )
liste.push_back( pd );
}
}
closedir(dirp);
}
}
Verzeichnis::~Verzeichnis()
{
for( Dateiliste::iterator it = liste.begin(); it != liste.end(); ++it )
delete *it;
}
void Verzeichnis::accept(Visitor& visitor)
{
visitor.visit(*this);
for (auto& d : liste)
d->accept(visitor);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
bool IsInstanceOf(const Datei* obj) noexcept {
return dynamic_cast< const T* >( obj ) != nullptr;
}
//////////////////////////
class VisitorPrintFiles : public Visitor
{
public:
VisitorPrintFiles() {};
~VisitorPrintFiles() {};
VisitorPrintFiles(VisitorPrintFiles&& rv) = delete;
void visit(Verzeichnis& v) override
{
std::cout << "verz:" << v.GibName() << std::endl;
}
void visit(Datei& d) override
{
std::cout << "datei:" << d.GibName() << std::endl;
}
};
class VisitorCountFiles : public Visitor
{
public:
VisitorCountFiles() {};
~VisitorCountFiles() {};
VisitorCountFiles(VisitorCountFiles&& rv) = delete;
void visit(Verzeichnis& v) override
{
std::cout << v.GibName() << ":" << v.liste.size() << std::endl;
}
void visit(Datei& d) override
{
std::cout << "visit.datei" << std::endl;
}
};
class VisitorRecursiveCountVerzeichnisse : public Visitor
{
public:
VisitorRecursiveCountVerzeichnisse() {};
~VisitorRecursiveCountVerzeichnisse() {};
void visit(Verzeichnis& v) override
{
//m_countFiles += std::count_if(v.liste.begin(), v.liste.end(), [](Datei* d) { return IsInstanceOf<Verzeichnis>(d); });
m_countFiles++;
}
void visit(Datei& d) override
{
}
int getCount() {
return m_countFiles;
}
private:
int m_countFiles = 0;
};
///////////////////////////////
int main( int argc, char *argv[] )
{
using namespace std;
string verz( argc > 1 ? argv[1] : "." );
VisitorPrintFiles v;
VisitorCountFiles vcf;
VisitorRecursiveCountVerzeichnisse vrcf;
Verzeichnis root( verz );
//root.accept(v);
//root.accept(vcf);
root.accept(vrcf);
std::cout << "count of all files=" << vrcf.getCount() << std::endl;
return 0;
}
| 4,653 | 1,932 |
/* ============================================================================================== *
* *
* Galaxia Blockchain *
* *
* ---------------------------------------------------------------------------------------------- *
* This file is part of the Xi framework. *
* ---------------------------------------------------------------------------------------------- *
* *
* Copyright 2018-2019 Xi Project Developers <support.xiproject.io> *
* *
* This program is free software: you can redistribute it and/or modify it under the terms of the *
* GNU General Public License as published by the Free Software Foundation, either version 3 of *
* the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; *
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *
* See the GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License along with this program. *
* If not, see <https://www.gnu.org/licenses/>. *
* *
* ============================================================================================== */
#pragma once
#include <cstring>
#include "Xi/Span.hpp"
#include "Xi/Byte.hh"
namespace Xi {
template <typename _T, size_t _Bytes>
struct enable_blob_from_this : protected ByteArray<_Bytes> {
using value_type = _T;
using array_type = ByteArray<_Bytes>;
static inline constexpr size_t bytes() { return _Bytes; }
enable_blob_from_this() { this->fill(0); }
explicit enable_blob_from_this(array_type raw) : array_type(std::move(raw)) {}
using array_type::data;
using array_type::fill;
using array_type::size;
using array_type::operator[];
ByteSpan span() { return ByteSpan{this->data(), this->size()}; }
ConstByteSpan span() const { return ConstByteSpan{this->data(), this->size()}; }
inline bool operator==(const value_type &rhs) { return ::std::memcmp(this->data(), rhs.data(), bytes()) == 0; }
inline bool operator!=(const value_type &rhs) { return ::std::memcmp(this->data(), rhs.data(), bytes()) != 0; }
};
} // namespace Xi
| 3,164 | 697 |
/*
Amine Rehioui
Created: November 18th 2011
*/
#include "ShootTest.h"
#include "BulletManager.h"
#include "GameManager.h"
namespace shoot
{
DEFINE_OBJECT(BulletManager);
//! Constructor
BulletManager::BulletManager()
// properties
: m_BulletPoolSize(4096)
{
}
//! serializes the entity to/from a PropertyStream
void BulletManager::Serialize(PropertyStream& stream)
{
super::Serialize(stream);
if(stream.Serialize(PT_UInt, "BulletPoolSize", &m_BulletPoolSize))
{
if(IsInitialized())
{
m_Pool = snew MemoryPool(m_BulletPoolSize);
m_Bullets.clear();
}
}
}
//! called during the initialization of the entity
void BulletManager::Init()
{
m_Pool = snew MemoryPool(m_BulletPoolSize);
GraphicComponent* pGraphic = GetComponent<GraphicComponent>();
if(!pGraphic)
{
pGraphic = snew GraphicComponent();
pGraphic->SetRenderingPass(GraphicComponent::RP_Transparent3D);
AddComponent(pGraphic, true);
}
super::Init();
}
//! called during the update of the entity
void BulletManager::Update()
{
VertexBuffer* pVB = GetComponent<GraphicComponent>()->GetVertexBuffer();
pVB->SetNumVertices(0);
if(m_Bullets.size())
{
u32 bulletIndex = 0;
for(std::list<Bullet*>::iterator it = m_Bullets.begin(); it != m_Bullets.end();)
{
if((*it)->fLife > 0.0f && !GameManager::Instance()->IsOutOfPlayfield((*it)->vPosition))
{
(*it)->vPosition += (*it)->vDirection*(*it)->fSpeed*g_fDeltaTime;
SetupRendering((*it), bulletIndex++, pVB);
(*it)->fLife -= g_fDeltaTime;
++it;
}
else
{
m_Pool->Free((*it));
it = m_Bullets.erase(it);
}
}
pVB->SetDirty(true);
}
}
//! Adds a bullet
void BulletManager::AddBullet(const Bullet::BulletParams& params)
{
if(Bullet* pBullet = m_Pool->Alloc<Bullet>())
{
pBullet->Init(params);
m_Bullets.push_back(pBullet);
}
}
//! clears the bullets
void BulletManager::Clear()
{
for(std::list<Bullet*>::iterator it = m_Bullets.begin(); it != m_Bullets.end(); ++it)
{
(*it)->fLife = 0.0f;
}
}
}
| 2,082 | 945 |
#ifndef HANDLE_HPP
#define HANDLE_HPP
namespace util {
/* This class is intended to only be instantiatable by the base and represents a
* pointer */
template <typename T, typename Base> class Handle {
public:
friend Base;
Handle() = default;
const T *get() { return p_; }
const Base *get_base() { return base_; }
const T &operator*() { return *p_; }
const T *operator->() { return p_; }
bool operator==(const Handle<T, Base> &other) const {
return p_ == other.p_ && base_ == other.base_;
}
private:
Handle(T *p, const Base *base) : p_{p}, base_{base} {}
T *p_ = nullptr;
const Base *base_ = nullptr;
};
}
#endif /* end of include guard: HANDLE_HPP */
| 687 | 242 |
#include "TracyFilesystem.hpp"
#include "TracyView.hpp"
namespace tracy
{
bool SourceFileValid( const char* fn, uint64_t olderThan, const View& view, const Worker& worker )
{
if( worker.GetSourceFileFromCache( fn ).data != nullptr ) return true;
struct stat buf;
if( stat( view.SourceSubstitution( fn ), &buf ) == 0 && ( buf.st_mode & S_IFREG ) != 0 )
{
return (uint64_t)buf.st_mtime < olderThan;
}
return false;
}
}
| 452 | 166 |
/** 080. Remove Duplicates from Sorted Array II
Follow up for "Remove Duplicates":
What if duplicates are allowed at most twice?
For example,
Given sorted array nums = [1,1,1,2,2,3],
Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3. It doesn't matter what you leave beyond the new length.
**/
#include <iostream>
#include "../utils.h"
using namespace std;
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
}
};
int main() {
Solution s;
return 0;
}
| 548 | 186 |
#include <aligner/aligner_edlib.h>
// #include "libs/edlibcigar.h"
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <zlib.h>
#include <aligner/aligner_util.hpp>
namespace raptor {
std::shared_ptr<AlignerBase> createAlignerEdlib(const raptor::AlignmentOptions& opt) {
return std::shared_ptr<AlignerBase>(new AlignerEdlib(opt));
}
AlignerEdlib::AlignerEdlib(const raptor::AlignmentOptions& opt) : opt_(opt) {}
AlignerEdlib::~AlignerEdlib() {}
std::vector<raptor::CigarOp> EdlibAlignmentToCigar(unsigned char* aln, int aln_len) {
std::vector<raptor::CigarOp> ret;
if (aln_len <= 0) {
return ret;
}
// Maps move code from alignment to char in cigar.
// 0 1 2 3
char op_to_cigar[] = {'=', 'I', 'D', 'X'};
char prev_op = 0; // Char of last move. 0 if there was no previous move.
int count = 0;
for (int i = 0; i <= aln_len; i++) {
if (i == aln_len || (op_to_cigar[aln[i]] != prev_op && prev_op != 0)) {
ret.emplace_back(raptor::CigarOp(prev_op, count));
count = 0;
}
if (i < aln_len) {
prev_op = op_to_cigar[aln[i]];
count += 1;
}
}
return ret;
}
std::shared_ptr<raptor::AlignmentResult> AlignerEdlib::Global(const char* qseq, int64_t qlen,
const char* tseq, int64_t tlen) {
return RunEdlib(qseq, qlen, tseq, tlen, opt_, EDLIB_MODE_NW, EDLIB_TASK_PATH);
}
std::shared_ptr<raptor::AlignmentResult> AlignerEdlib::Extend(const char* qseq, int64_t qlen,
const char* tseq, int64_t tlen) {
auto result = raptor::createAlignmentResult();
if (qseq == NULL || tseq == NULL || qlen <= 0 || tlen <= 0) {
result->status(raptor::AlignmentReturnValue::InvalidOptions);
return result;
}
result = RunEdlib(qseq, qlen, tseq, tlen, opt_, EDLIB_MODE_SHW, EDLIB_TASK_PATH);
auto aln_vec = CigarToAlignmentArray(result->cigar());
int64_t score = (opt_.end_bonus >= 0) ? opt_.end_bonus : 0;
// bool stop_ext_on_zero_score = (opt_.zdrop == -99912345) ? false : true; // Emulates local alignment if true. This might prevent end-to-end extensions, so allow a hidden feature to enable end-to-end extensions. These can severely reduce alignment score / identity.
int64_t max_score = -1000000000; // Large negative value;
int64_t max_q = 0;
int64_t max_t = 0;
int64_t drop_q = 0, drop_t = 0, drop_score = 0;
int64_t qpos = 0, tpos = 0;
size_t final_i = 0;
int64_t edit_dist = 0;
bool stop_loop = false;
char prev_op = 'Z';
int32_t streak = 1;
for (size_t i = 0; i < aln_vec.size(); ++i) {
char op = aln_vec[i];
streak = (op == prev_op) ? (streak + 1) : 1;
// int32_t count = 1; // streak;
final_i = i;
// std::cerr << "op = " << op << ", prev_op = " << prev_op << ", count = " << 1 << ", i = " << i << ", score = " << score << "\n";
prev_op = op;
switch (op) {
case '=':
score += opt_.p.match;
qpos += 1;
tpos += 1;
break;
case 'X':
score += opt_.p.mismatch;
qpos += 1;
tpos += 1;
edit_dist += 1;
break;
case 'I':
if (streak == 1) {
score += opt_.p.w[0].open; // Gap open only if a new streak is found.
}
score += opt_.p.w[0].ext; // This is the gap extend penalty.
qpos += 1;
edit_dist += 1;
break;
case 'D':
if (streak == 1) {
score += opt_.p.w[0].open; // Gap open only if a new streak is found.
}
score += opt_.p.w[0].ext; // This is the gap extend penalty.
tpos += 1;
edit_dist += 1;
break;
default:
// If an unknown op is found, don't do zdrop.
max_score = -1000000000;
qpos = qlen;
tpos = tlen;
score = result->score();
final_i = result->cigar().size();
stop_loop = true;
break;
}
if (score > max_score) {
max_score = score;
max_q = qpos;
max_t = tpos;
}
if (qpos >= qlen || tpos >= tlen) {
// std::cerr << "Break 1!\n";
break;
}
if (opt_.stop_ext_on_zero_score && score < 0) {
// std::cerr << "Break 2!\n";
break;
}
if (stop_loop == true) {
// std::cerr << "Break 3!\n";
break;
}
if (opt_.zdrop >= 0 && score < (max_score - opt_.zdrop)) {
// std::cerr << "Break 4!\n";
break;
}
}
if (final_i == aln_vec.size()) {
return result;
}
// std::cerr << "max_score = " << max_score << ", score = " << score << "\n";
// std::cerr << "cigar = " << raptor::CigarToString(result->cigar(), false) << "\n";
std::vector<raptor::CigarOp> new_cigar =
AlignmentArrayToCigar((const unsigned char*)&aln_vec[0], final_i + 1);
result->cigar(new_cigar);
result->score(score);
result->position(raptor::AlignmentPosition(0, qpos, 0, tpos));
result->max_score(max_score);
result->max_q_pos(max_q);
result->max_t_pos(max_t);
result->edit_dist(edit_dist);
result->final_band(-1);
result->status(raptor::AlignmentReturnValue::OK);
return result;
}
std::shared_ptr<raptor::AlignmentResult> AlignerEdlib::Local(const char* qseq, int64_t qlen,
const char* tseq, int64_t tlen) {
auto result = raptor::createAlignmentResult();
if (qseq == NULL || tseq == NULL || qlen <= 0 || tlen <= 0) {
result->status(raptor::AlignmentReturnValue::InvalidOptions);
return result;
}
result->status(raptor::AlignmentReturnValue::NotImplementedYet);
return result;
}
std::shared_ptr<raptor::AlignmentResult> AlignerEdlib::Semiglobal(const char* qseq, int64_t qlen,
const char* tseq, int64_t tlen) {
auto result = raptor::createAlignmentResult();
if (qseq == NULL || tseq == NULL || qlen <= 0 || tlen <= 0) {
result->status(raptor::AlignmentReturnValue::InvalidOptions);
return result;
}
result->status(raptor::AlignmentReturnValue::NotImplementedYet);
return result;
}
std::shared_ptr<raptor::AlignmentResult> AlignerEdlib::RunEdlib(const char* qseq, int64_t qlen,
const char* tseq, int64_t tlen,
const raptor::AlignmentOptions& opt,
EdlibAlignMode edlib_mode,
EdlibAlignTask edlib_task) {
auto result = raptor::createAlignmentResult();
if (qseq == NULL || tseq == NULL || qlen <= 0 || tlen <= 0) {
result->status(raptor::AlignmentReturnValue::InvalidOptions);
return result;
}
result->status(raptor::AlignmentReturnValue::AlignerFailure);
EdlibAlignResult edlib_result =
edlibAlign((const char*)qseq, qlen, (const char*)tseq, tlen,
edlibNewAlignConfig(opt.bandwidth, edlib_mode, edlib_task));
if (edlib_result.numLocations == 0) {
edlibFreeAlignResult(edlib_result);
result->status(raptor::AlignmentReturnValue::AlignerFailure);
return result;
}
// result->score(-edlib_result.editDistance);
result->edit_dist(edlib_result.editDistance);
result->position(raptor::AlignmentPosition(0, qlen, 0, tlen));
result->final_band(-1);
result->status(raptor::AlignmentReturnValue::OK);
result->max_q_pos(qlen);
result->max_t_pos(tlen);
result->cigar(EdlibAlignmentToCigar(edlib_result.alignment, edlib_result.alignmentLength));
int64_t score = ScoreCigarAlignment(result->cigar(), opt.p.match, opt.p.mismatch, opt.p.w[0].open, opt.p.w[0].ext);
result->score(score);
result->max_score(result->score());
edlibFreeAlignResult(edlib_result);
return result;
}
} // namespace raptor
| 8,602 | 2,932 |
#ifndef PCP_TRAITS_POINT_TRAITS_HPP
#define PCP_TRAITS_POINT_TRAITS_HPP
/**
* @file
* @ingroup traits
*/
#include <type_traits>
namespace pcp {
namespace traits {
/**
* @ingroup traits-geometry
* @brief
* PointView requirements:
* - coordinate_type type member
* - copy constructible
* - copy assignable
* - move constructible
* - move assignable
* - x,y,z getters
* - x,y,z setters
* - equality/inequality operator
* @tparam PointView Type to inspect
*/
template <class PointView, class = void>
struct is_point_view : std::false_type
{
};
template <class PointView>
struct is_point_view<
PointView,
std::void_t<
typename PointView::coordinate_type,
decltype(std::declval<PointView&>().x()),
decltype(std::declval<PointView&>().y()),
decltype(std::declval<PointView&>().z()),
decltype(std::declval<PointView&>().x(std::declval<typename PointView::coordinate_type>())),
decltype(std::declval<PointView&>().y(std::declval<typename PointView::coordinate_type>())),
decltype(std::declval<PointView&>().z(
std::declval<typename PointView::coordinate_type>()))>> : std::true_type
{
static_assert(std::is_copy_constructible_v<PointView>, "PointView must be copy constructible");
static_assert(std::is_copy_assignable_v<PointView>, "PointView must be copy assignable");
};
/**
* @ingroup traits-geometry
* @brief
* Compile-time check for PointView concept
* @tparam PointView
*/
template <class PointView>
static constexpr bool is_point_view_v = is_point_view<PointView>::value;
/**
* @ingroup traits-geometry
* @brief
* Point requirements (refines PointView):
* - default constructible
* - parameter constructor from x,y,z
* - *,/,+,- operators
*/
template <class Point, class = void>
struct is_point : std::false_type
{
};
template <class Point>
struct is_point<
Point,
std::void_t<
decltype(std::declval<typename Point::coordinate_type>() * std::declval<Point&>()),
decltype(std::declval<Point&>() / std::declval<typename Point::coordinate_type>()),
decltype(std::declval<Point&>() + std::declval<Point&>()),
decltype(std::declval<Point&>() - std::declval<Point&>()),
decltype(-std::declval<Point&>())>> : is_point_view<Point>
{
static_assert(std::is_default_constructible_v<Point>, "Point must be default constructible");
static_assert(
std::is_constructible_v<
Point,
typename Point::coordinate_type,
typename Point::coordinate_type,
typename Point::coordinate_type>,
"Point must be constructible from (x,y,z) coordinates");
};
/**
* @ingroup traits-geometry
* @brief
* Compile-time check for Point concept
* @tparam Point
*/
template <class Point>
static constexpr bool is_point_v = is_point<Point>::value;
template <class PointView1, class PointView2, class = void>
struct is_point_view_equality_comparable_to : std::false_type
{
};
template <class PointView1, class PointView2>
struct is_point_view_equality_comparable_to<
PointView1,
PointView2,
std::void_t<
decltype(std::declval<PointView1&>() == std::declval<PointView2&>()),
decltype(std::declval<PointView1&>() != std::declval<PointView2&>())>> : std::true_type
{
};
/**
* @ingroup traits
* @brief
* Compile-time check to verify if PointView1 is equality/inequality comparable to PointView2
* @tparam PointView1
* @tparam PointView2
*/
template <class PointView1, class PointView2>
static constexpr bool is_point_view_equality_comparable_to_v =
is_point_view_equality_comparable_to<PointView1, PointView2>::value;
template <class PointView1, class PointView2, class = void>
struct is_point_view_assignable_from : std::false_type
{
};
template <class PointView1, class PointView2>
struct is_point_view_assignable_from<
PointView1,
PointView2,
std::void_t<decltype(std::declval<PointView1&>() = std::declval<PointView2&>())>>
: std::true_type
{
};
/**
* @ingroup traits
* @brief
* Compile-time check to verify is PointView1 is assignable from PointView2
* @tparam PointView1
* @tparam PointView2
*/
template <class PointView1, class PointView2>
static constexpr bool is_point_view_assignable_from_v =
is_point_view_assignable_from<PointView1, PointView2>::value;
} // namespace traits
} // namespace pcp
#endif // PCP_TRAITS_POINT_TRAITS_HPP | 4,413 | 1,471 |
/* Copyright 2011 Dirk-Willem van Gulik, All Rights Reserved.
* dirkx(at)webweaving(dot)org
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* $Id: QuadratureAnalyserAnalyzer.cpp 1037 2011-09-12 09:49:58Z dirkx $
*/
#include "QuadratureAnalyserAnalyzer.h"
#include "QuadratureAnalyserAnalyzerSettings.h"
#include <AnalyzerChannelData.h>
static change_t qe_decode(unsigned char olda, unsigned char oldb, unsigned char newa, unsigned char newb)
{
change_t oldnew[16] = { // AB -> AB which is (old state) --> (new state)
STANDSTILL , // 00 -> 00
CLOCKWISE , // 00 -> 01 -1
COUNTERCW , // 00 -> 10 +1
GLITCH , // 00 -> 11
COUNTERCW , // 01 -> 00 +1
STANDSTILL , // 01 -> 01
GLITCH , // 01 -> 10
CLOCKWISE , // 01 -> 11 -1
CLOCKWISE , // 10 -> 00 -1
GLITCH , // 10 -> 01
STANDSTILL , // 10 -> 10
COUNTERCW , // 10 -> 11 +1
GLITCH , // 11 -> 00
COUNTERCW , // 11 -> 01 +1
CLOCKWISE , // 11 -> 10 -1
STANDSTILL , // 11 -> 11
};
unsigned char state = 0;
state += olda ? 1 : 0;
state += oldb ? 2 : 0;
state += newa ? 4 : 0;
state += newb ? 8 : 0;
return oldnew[state];
}
QuadratureAnalyserAnalyzer::QuadratureAnalyserAnalyzer()
: Analyzer(),
mSettings( new QuadratureAnalyserAnalyzerSettings() )
{
SetAnalyzerSettings( mSettings.get() );
}
QuadratureAnalyserAnalyzer::~QuadratureAnalyserAnalyzer()
{
KillThread();
}
void QuadratureAnalyserAnalyzer::WorkerThread()
{
mResults.reset( new QuadratureAnalyserAnalyzerResults( this, mSettings.get() ) );
SetAnalyzerResults( mResults.get() );
if (mSettings->mInputChannelA != UNDEFINED_CHANNEL)
mResults->AddChannelBubblesWillAppearOn( mSettings->mInputChannelA );
if (mSettings->mInputChannelB != UNDEFINED_CHANNEL)
mResults->AddChannelBubblesWillAppearOn( mSettings->mInputChannelB );
AnalyzerChannelData * mChannelA = GetAnalyzerChannelData( mSettings->mInputChannelA );
AnalyzerChannelData * mChannelB = GetAnalyzerChannelData( mSettings->mInputChannelB );
U8 mLastA = mChannelA->GetBitState() == BIT_HIGH ? 1 : 0;
U8 mLastB = mChannelB->GetBitState() == BIT_HIGH ? 1 : 0;
change_t lastDir = GLITCH;
U64 lastStart = mChannelA->GetSampleNumber();
U64 lastEnd = mChannelA->GetSampleNumber();
U64 curEnd = mChannelA->GetSampleNumber();
U32 glitchCount = 0;
U32 tickCount = 0;
int64_t posCount = 0;
for( ; ; )
{
AnalyzerResults::MarkerType m;
int result = 0;
U64 a,b,c;
#if 0
mChannelA->Advance(1);
mChannelB->Advance(1);
U8 mNewA = mChannelA->GetBitState() == BIT_HIGH ? 1 : 0;
U8 mNewB = mChannelB->GetBitState() == BIT_HIGH ? 1 : 0;
#else
a = mChannelA->GetSampleNumber();
b = mChannelB->GetSampleNumber();
if (a<=b) {
mChannelA->AdvanceToNextEdge();
};
if (b<=a) {
mChannelB->AdvanceToNextEdge();
};
a = mChannelA->GetSampleNumber();
b = mChannelB->GetSampleNumber();
U8 mNewA = mLastA;
U8 mNewB = mLastB;
if (a<=b) {
mNewA = mChannelA->GetBitState() == BIT_HIGH ? 1 : 0;
c = a;
};
if (b<=a) {
mNewB = mChannelB->GetBitState() == BIT_HIGH ? 1 : 0;
c = b;
};
#endif
change_t dir = qe_decode(mLastA, mLastB, mNewA, mNewB);
mLastA = mNewA;
mLastB = mNewB;
if (dir == STANDSTILL)
continue;
switch(dir) {
case CLOCKWISE:
case COUNTERCW:
m = (dir == CLOCKWISE) ? AnalyzerResults::DownArrow : AnalyzerResults::UpArrow;
mResults->AddMarker( c, m, mSettings->mInputChannelA );
mResults->AddMarker( c, m, mSettings->mInputChannelB );
result ++;
tickCount++;
posCount += (m == CLOCKWISE) ? -1 : 1;
lastEnd = curEnd;
curEnd = c;
break;
default:
glitchCount++;
break;
};
if (dir != lastDir) {
// skip any initial glitches. We're not sure what they are anyway.
//
if (glitchCount != 0 || lastDir != GLITCH) {
Frame frame;
frame.mData1 = (posCount << 32) | lastDir;
frame.mData2 = ((U64)tickCount << 32) | (glitchCount << 0);
frame.mFlags = 0;
frame.mStartingSampleInclusive = lastStart;
frame.mEndingSampleInclusive = lastEnd;
mResults->AddFrame( frame );
}
lastStart = curEnd;
lastDir = dir;
result ++;
tickCount = 0;
glitchCount = 0;
};
if (result) {
mResults->CommitResults();
ReportProgress(c);
};
}
}
bool QuadratureAnalyserAnalyzer::NeedsRerun()
{
return false;
}
U32 QuadratureAnalyserAnalyzer::GenerateSimulationData( U64 minimum_sample_index, U32 device_sample_rate, SimulationChannelDescriptor** simulation_channels )
{
mSimulationDataGenerator.Initialize( GetSimulationSampleRate(), mSettings.get() );
return mSimulationDataGenerator.GenerateSimulationData( minimum_sample_index,
device_sample_rate, simulation_channels );
}
U32 QuadratureAnalyserAnalyzer::GetMinimumSampleRateHz()
{
return SCANRATE;
}
const char* QuadratureAnalyserAnalyzer::GetAnalyzerName() const
{
return "Quadrature Decoder";
}
const char* GetAnalyzerName()
{
// return MYVERSION;
return "Quadrature Decoder";
}
Analyzer* CreateAnalyzer()
{
return new QuadratureAnalyserAnalyzer();
}
void DestroyAnalyzer( Analyzer* analyzer )
{
delete analyzer;
}
| 5,952 | 2,532 |
#ifndef RS_DATA_OBJ_OPEN_AND_STAT_HPP
#define RS_DATA_OBJ_OPEN_AND_STAT_HPP
#include "rcConnect.h"
#include "dataObjInpOut.h"
#include "dataObjOpenAndStat.h"
int rsDataObjOpenAndStat( rsComm_t *rsComm, dataObjInp_t *dataObjInp, openStat_t **openStat );
#endif
| 263 | 119 |
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include "base/memory/ptr_util.h"
#include "base/run_loop.h"
#include "cc/animation/animation_host.h"
#include "cc/blimp/layer_tree_host_remote.h"
#include "cc/layers/empty_content_layer_client.h"
#include "cc/layers/layer.h"
#include "cc/layers/solid_color_scrollbar_layer.h"
#include "cc/proto/layer.pb.h"
#include "cc/proto/layer_tree_host.pb.h"
#include "cc/test/fake_image_serialization_processor.h"
#include "cc/test/fake_layer_tree_host.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_picture_layer.h"
#include "cc/test/fake_recording_source.h"
#include "cc/test/remote_client_layer_factory.h"
#include "cc/test/remote_compositor_test.h"
#include "cc/test/serialization_test_utils.h"
#include "cc/trees/layer_tree.h"
#include "cc/trees/layer_tree_host_common.h"
#include "cc/trees/layer_tree_settings.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/vector2d_f.h"
namespace cc {
#define EXPECT_CLIENT_LAYER_DIRTY(engine_layer) \
do { \
Layer* client_layer = compositor_state_deserializer_->GetLayerForEngineId( \
engine_layer->id()); \
LayerTree* client_tree = client_layer->GetLayerTree(); \
EXPECT_TRUE( \
client_tree->LayerNeedsPushPropertiesForTesting(client_layer)); \
} while (false)
class LayerTreeHostSerializationTest : public RemoteCompositorTest {
protected:
void VerifySerializationAndDeserialization() {
// Synchronize state.
CHECK(HasPendingUpdate());
base::RunLoop().RunUntilIdle();
VerifySerializedTreesAreIdentical(
layer_tree_host_remote_->GetLayerTree(),
layer_tree_host_in_process_->GetLayerTree(),
compositor_state_deserializer_.get());
}
void SetUpViewportLayers(LayerTree* engine_layer_tree) {
scoped_refptr<Layer> overscroll_elasticity_layer = Layer::Create();
scoped_refptr<Layer> page_scale_layer = Layer::Create();
scoped_refptr<Layer> inner_viewport_scroll_layer = Layer::Create();
scoped_refptr<Layer> outer_viewport_scroll_layer = Layer::Create();
engine_layer_tree->root_layer()->AddChild(overscroll_elasticity_layer);
engine_layer_tree->root_layer()->AddChild(page_scale_layer);
engine_layer_tree->root_layer()->AddChild(inner_viewport_scroll_layer);
engine_layer_tree->root_layer()->AddChild(outer_viewport_scroll_layer);
engine_layer_tree->RegisterViewportLayers(
overscroll_elasticity_layer, page_scale_layer,
inner_viewport_scroll_layer, outer_viewport_scroll_layer);
}
};
TEST_F(LayerTreeHostSerializationTest, AllMembersChanged) {
LayerTree* engine_layer_tree = layer_tree_host_remote_->GetLayerTree();
engine_layer_tree->SetRootLayer(Layer::Create());
scoped_refptr<Layer> mask_layer = Layer::Create();
engine_layer_tree->root_layer()->SetMaskLayer(mask_layer.get());
SetUpViewportLayers(engine_layer_tree);
engine_layer_tree->SetViewportSize(gfx::Size(3, 14));
engine_layer_tree->SetDeviceScaleFactor(4.f);
engine_layer_tree->SetPaintedDeviceScaleFactor(2.f);
engine_layer_tree->SetPageScaleFactorAndLimits(2.f, 0.5f, 3.f);
engine_layer_tree->set_background_color(SK_ColorMAGENTA);
engine_layer_tree->set_has_transparent_background(true);
LayerSelectionBound sel_bound;
sel_bound.edge_top = gfx::Point(14, 3);
LayerSelection selection;
selection.start = sel_bound;
engine_layer_tree->RegisterSelection(selection);
VerifySerializationAndDeserialization();
}
TEST_F(LayerTreeHostSerializationTest, LayersChangedMultipleSerializations) {
LayerTree* engine_layer_tree = layer_tree_host_remote_->GetLayerTree();
engine_layer_tree->SetRootLayer(Layer::Create());
SetUpViewportLayers(engine_layer_tree);
VerifySerializationAndDeserialization();
scoped_refptr<Layer> new_child = Layer::Create();
engine_layer_tree->root_layer()->AddChild(new_child);
engine_layer_tree->RegisterViewportLayers(nullptr, nullptr, nullptr, nullptr);
VerifySerializationAndDeserialization();
engine_layer_tree->SetRootLayer(nullptr);
VerifySerializationAndDeserialization();
}
TEST_F(LayerTreeHostSerializationTest, AddAndRemoveNodeFromLayerTree) {
/* Testing serialization when the tree hierarchy changes like this:
root root
/ \ / \
a b => a c
\ \
c d
*/
LayerTree* engine_layer_tree = layer_tree_host_remote_->GetLayerTree();
scoped_refptr<Layer> layer_src_root = Layer::Create();
engine_layer_tree->SetRootLayer(layer_src_root);
scoped_refptr<Layer> layer_src_a = Layer::Create();
scoped_refptr<Layer> layer_src_b = Layer::Create();
scoped_refptr<Layer> layer_src_c = Layer::Create();
scoped_refptr<Layer> layer_src_d = Layer::Create();
layer_src_root->AddChild(layer_src_a);
layer_src_root->AddChild(layer_src_b);
layer_src_b->AddChild(layer_src_c);
VerifySerializationAndDeserialization();
// Now change the Layer Hierarchy
layer_src_c->RemoveFromParent();
layer_src_b->RemoveFromParent();
layer_src_root->AddChild(layer_src_c);
layer_src_c->AddChild(layer_src_d);
VerifySerializationAndDeserialization();
}
TEST_F(LayerTreeHostSerializationTest, TestNoExistingRoot) {
/* Test deserialization of a tree that looks like:
root
/ \
a b
\
c
There is no existing root node before serialization.
*/
scoped_refptr<Layer> old_root_layer = Layer::Create();
scoped_refptr<Layer> layer_a = Layer::Create();
scoped_refptr<Layer> layer_b = Layer::Create();
scoped_refptr<Layer> layer_c = Layer::Create();
old_root_layer->AddChild(layer_a);
old_root_layer->AddChild(layer_b);
layer_b->AddChild(layer_c);
layer_tree_host_remote_->GetLayerTree()->SetRootLayer(old_root_layer);
VerifySerializationAndDeserialization();
// Swap the root node.
scoped_refptr<Layer> new_root_layer = Layer::Create();
new_root_layer->AddChild(layer_a);
new_root_layer->AddChild(layer_b);
layer_tree_host_remote_->GetLayerTree()->SetRootLayer(old_root_layer);
VerifySerializationAndDeserialization();
}
TEST_F(LayerTreeHostSerializationTest, RecursivePropertiesSerialization) {
/* Testing serialization of properties for a tree that looks like this:
root+
/ \
a* b+[mask:*]
/ \
c d
Layers marked with * have changed properties.
Layers marked with + have descendants with changed properties.
Layer b also has a mask layer.
*/
scoped_refptr<Layer> layer_src_root = Layer::Create();
scoped_refptr<Layer> layer_src_a = Layer::Create();
scoped_refptr<Layer> layer_src_b = Layer::Create();
scoped_refptr<Layer> layer_src_b_mask = Layer::Create();
scoped_refptr<Layer> layer_src_c = Layer::Create();
scoped_refptr<Layer> layer_src_d = Layer::Create();
layer_src_root->AddChild(layer_src_a);
layer_src_root->AddChild(layer_src_b);
layer_src_a->AddChild(layer_src_c);
layer_src_b->AddChild(layer_src_d);
layer_src_b->SetMaskLayer(layer_src_b_mask.get());
layer_tree_host_remote_->GetLayerTree()->SetRootLayer(layer_src_root);
VerifySerializationAndDeserialization();
EXPECT_EQ(layer_tree_host_remote_->GetLayerTree()
->LayersThatShouldPushProperties()
.size(),
0u);
EXPECT_EQ(layer_tree_host_in_process_->GetLayerTree()
->LayersThatShouldPushProperties()
.size(),
6u);
}
TEST_F(LayerTreeHostSerializationTest, ChildrenOrderChange) {
/* Testing serialization and deserialization of a tree that initially looks
like this:
root
/ \
a b
The children are then re-ordered and changed to:
root
/ \
b a
\
c
*/
scoped_refptr<Layer> layer_src_root = Layer::Create();
layer_tree_host_remote_->GetLayerTree()->SetRootLayer(layer_src_root);
scoped_refptr<Layer> layer_src_a = Layer::Create();
scoped_refptr<Layer> layer_src_b = Layer::Create();
layer_src_root->AddChild(layer_src_b);
layer_src_root->AddChild(layer_src_a);
VerifySerializationAndDeserialization();
Layer* client_root =
compositor_state_deserializer_->GetLayerForEngineId(layer_src_root->id());
Layer* client_a =
compositor_state_deserializer_->GetLayerForEngineId(layer_src_a->id());
Layer* client_b =
compositor_state_deserializer_->GetLayerForEngineId(layer_src_b->id());
// Swap the children.
layer_src_root->RemoveAllChildren();
layer_src_root->AddChild(layer_src_a);
layer_src_root->AddChild(layer_src_b);
layer_src_a->AddChild(Layer::Create());
VerifySerializationAndDeserialization();
// Verify all old layers are re-used.
Layer* new_client_root =
compositor_state_deserializer_->GetLayerForEngineId(layer_src_root->id());
Layer* new_client_a =
compositor_state_deserializer_->GetLayerForEngineId(layer_src_a->id());
Layer* new_client_b =
compositor_state_deserializer_->GetLayerForEngineId(layer_src_b->id());
EXPECT_EQ(client_root, new_client_root);
EXPECT_EQ(client_a, new_client_a);
EXPECT_EQ(client_b, new_client_b);
}
TEST_F(LayerTreeHostSerializationTest, DeletingLayers) {
/* Testing serialization and deserialization of a tree that initially
looks like this:
root
/ \
a b
\
c+[mask:*]
First the mask layer is deleted.
Then the subtree from node |b| is deleted in the next update.
*/
scoped_refptr<Layer> layer_src_root = Layer::Create();
layer_tree_host_remote_->GetLayerTree()->SetRootLayer(layer_src_root);
scoped_refptr<Layer> layer_src_a = Layer::Create();
scoped_refptr<Layer> layer_src_b = Layer::Create();
scoped_refptr<Layer> layer_src_c = Layer::Create();
scoped_refptr<Layer> layer_src_c_mask = Layer::Create();
layer_src_root->AddChild(layer_src_a);
layer_src_root->AddChild(layer_src_b);
layer_src_b->AddChild(layer_src_c);
layer_src_c->SetMaskLayer(layer_src_c_mask.get());
VerifySerializationAndDeserialization();
// Delete the mask layer.
layer_src_c->SetMaskLayer(nullptr);
VerifySerializationAndDeserialization();
// Remove child b.
layer_src_b->RemoveFromParent();
VerifySerializationAndDeserialization();
}
TEST_F(LayerTreeHostSerializationTest, LayerDataSerialization) {
scoped_refptr<Layer> layer = Layer::Create();
layer_tree_host_remote_->GetLayerTree()->SetRootLayer(layer);
VerifySerializationAndDeserialization();
// Change all the fields.
layer->SetTransformOrigin(gfx::Point3F(3.0f, 1.0f, 4.0f));
layer->SetBackgroundColor(SK_ColorRED);
layer->SetBounds(gfx::Size(3, 14));
layer->SetDoubleSided(!layer->double_sided());
layer->SetHideLayerAndSubtree(!layer->hide_layer_and_subtree());
layer->SetMasksToBounds(!layer->masks_to_bounds());
layer->AddMainThreadScrollingReasons(
MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
layer->SetNonFastScrollableRegion(Region(gfx::Rect(5, 1, 14, 3)));
layer->SetNonFastScrollableRegion(Region(gfx::Rect(3, 14, 1, 5)));
layer->SetContentsOpaque(!layer->contents_opaque());
layer->SetOpacity(0.4f);
layer->SetBlendMode(SkXfermode::kOverlay_Mode);
layer->SetIsRootForIsolatedGroup(!layer->is_root_for_isolated_group());
layer->SetPosition(gfx::PointF(3.14f, 6.28f));
layer->SetIsContainerForFixedPositionLayers(
!layer->IsContainerForFixedPositionLayers());
LayerPositionConstraint pos_con;
pos_con.set_is_fixed_to_bottom_edge(true);
layer->SetPositionConstraint(pos_con);
layer->SetShouldFlattenTransform(!layer->should_flatten_transform());
layer->SetUseParentBackfaceVisibility(
!layer->use_parent_backface_visibility());
gfx::Transform transform;
transform.Rotate(90);
layer->SetTransform(transform);
layer->Set3dSortingContextId(42);
layer->SetUserScrollable(layer->user_scrollable_horizontal(),
layer->user_scrollable_vertical());
layer->SetScrollOffset(gfx::ScrollOffset(3, 14));
gfx::Rect update_rect(14, 15);
layer->SetNeedsDisplayRect(update_rect);
VerifySerializationAndDeserialization();
Layer* client_layer =
compositor_state_deserializer_->GetLayerForEngineId(layer->id());
EXPECT_EQ(update_rect, client_layer->update_rect());
}
TEST_F(LayerTreeHostSerializationTest, SolidColorScrollbarLayer) {
scoped_refptr<Layer> root_layer = Layer::Create();
layer_tree_host_remote_->GetLayerTree()->SetRootLayer(root_layer);
scoped_refptr<Layer> child_layer = Layer::Create();
root_layer->AddChild(child_layer);
std::vector<scoped_refptr<SolidColorScrollbarLayer>> scrollbar_layers;
scrollbar_layers.push_back(SolidColorScrollbarLayer::Create(
ScrollbarOrientation::HORIZONTAL, 20, 5, true, root_layer->id()));
scrollbar_layers.push_back(SolidColorScrollbarLayer::Create(
ScrollbarOrientation::VERTICAL, 20, 5, false, child_layer->id()));
scrollbar_layers.push_back(SolidColorScrollbarLayer::Create(
ScrollbarOrientation::HORIZONTAL, 0, 0, true, root_layer->id()));
scrollbar_layers.push_back(SolidColorScrollbarLayer::Create(
ScrollbarOrientation::VERTICAL, 10, 35, true, child_layer->id()));
for (const auto& layer : scrollbar_layers) {
root_layer->AddChild(layer);
}
VerifySerializationAndDeserialization();
for (const auto& engine_layer : scrollbar_layers) {
VerifySerializedScrollbarLayersAreIdentical(
engine_layer.get(), compositor_state_deserializer_.get());
}
}
TEST_F(LayerTreeHostSerializationTest, PictureLayerSerialization) {
// Override the layer factor to create FakePictureLayers in the deserializer.
compositor_state_deserializer_->SetLayerFactoryForTesting(
base::MakeUnique<RemoteClientLayerFactory>());
LayerTree* engine_layer_tree = layer_tree_host_remote_->GetLayerTree();
scoped_refptr<Layer> root_layer_src = Layer::Create();
engine_layer_tree->SetRootLayer(root_layer_src);
// Ensure that a PictureLayer work correctly for multiple rounds of
// serialization and deserialization.
FakeContentLayerClient content_client;
gfx::Size bounds(256, 256);
content_client.set_bounds(bounds);
SkPaint simple_paint;
simple_paint.setColor(SkColorSetARGB(255, 12, 23, 34));
content_client.add_draw_rect(gfx::Rect(bounds), simple_paint);
scoped_refptr<FakePictureLayer> picture_layer_src =
FakePictureLayer::Create(&content_client);
root_layer_src->AddChild(picture_layer_src);
picture_layer_src->SetNearestNeighbor(!picture_layer_src->nearest_neighbor());
picture_layer_src->SetNeedsDisplay();
VerifySerializationAndDeserialization();
layer_tree_host_in_process_->UpdateLayers();
VerifySerializedPictureLayersAreIdentical(
picture_layer_src.get(), compositor_state_deserializer_.get());
// Another round.
picture_layer_src->SetNeedsDisplay();
SkPaint new_paint;
new_paint.setColor(SkColorSetARGB(255, 12, 32, 44));
content_client.add_draw_rect(gfx::Rect(bounds), new_paint);
VerifySerializationAndDeserialization();
layer_tree_host_in_process_->UpdateLayers();
VerifySerializedPictureLayersAreIdentical(
picture_layer_src.get(), compositor_state_deserializer_.get());
}
TEST_F(LayerTreeHostSerializationTest, EmptyPictureLayerSerialization) {
// Override the layer factor to create FakePictureLayers in the deserializer.
compositor_state_deserializer_->SetLayerFactoryForTesting(
base::MakeUnique<RemoteClientLayerFactory>());
LayerTree* engine_layer_tree = layer_tree_host_remote_->GetLayerTree();
scoped_refptr<Layer> root_layer_src = Layer::Create();
engine_layer_tree->SetRootLayer(root_layer_src);
scoped_refptr<FakePictureLayer> picture_layer_src =
FakePictureLayer::Create(EmptyContentLayerClient::GetInstance());
root_layer_src->AddChild(picture_layer_src);
picture_layer_src->SetNeedsDisplay();
VerifySerializationAndDeserialization();
layer_tree_host_in_process_->UpdateLayers();
VerifySerializedPictureLayersAreIdentical(
picture_layer_src.get(), compositor_state_deserializer_.get());
}
} // namespace cc
| 16,656 | 5,648 |
#include "brightray/common/application_info.h"
#include <memory>
#include "base/file_version_info.h"
#include "base/strings/utf_string_conversions.h"
namespace brightray {
std::string GetApplicationName() {
auto module = GetModuleHandle(nullptr);
std::unique_ptr<FileVersionInfo> info(
FileVersionInfo::CreateFileVersionInfoForModule(module));
return base::UTF16ToUTF8(info->product_name());
}
std::string GetApplicationVersion() {
auto module = GetModuleHandle(nullptr);
std::unique_ptr<FileVersionInfo> info(
FileVersionInfo::CreateFileVersionInfoForModule(module));
return base::UTF16ToUTF8(info->product_version());
}
} // namespace brightray
| 678 | 212 |
/*
* Automatically Generated from Mathematica.
* Mon 25 Jun 2018 14:53:24 GMT-04:00
*/
#ifdef MATLAB_MEX_FILE
#include <stdexcept>
#include <cmath>
/**
* Copied from Wolfram Mathematica C Definitions file mdefs.hpp
* Changed marcos to inline functions (Eric Cousineau)
*/
inline double Power(double x, double y) { return pow(x, y); }
inline double Sqrt(double x) { return sqrt(x); }
inline double Abs(double x) { return fabs(x); }
inline double Exp(double x) { return exp(x); }
inline double Log(double x) { return log(x); }
inline double Sin(double x) { return sin(x); }
inline double Cos(double x) { return cos(x); }
inline double Tan(double x) { return tan(x); }
inline double ArcSin(double x) { return asin(x); }
inline double ArcCos(double x) { return acos(x); }
inline double ArcTan(double x) { return atan(x); }
/* update ArcTan function to use atan2 instead. */
inline double ArcTan(double x, double y) { return atan2(y,x); }
inline double Sinh(double x) { return sinh(x); }
inline double Cosh(double x) { return cosh(x); }
inline double Tanh(double x) { return tanh(x); }
const double E = 2.71828182845904523536029;
const double Pi = 3.14159265358979323846264;
const double Degree = 0.01745329251994329576924;
#endif
/*
* Sub functions
*/
static void output1(double *p_output1,const double *var1)
{
double t2124;
double t2089;
double t2134;
double t2101;
double t2138;
double t328;
double t2109;
double t2149;
double t2160;
double t2181;
double t2185;
double t2186;
double t2213;
double t2244;
double t2249;
double t2251;
double t2258;
double t2238;
double t2240;
double t2243;
double t2324;
double t2413;
double t2416;
double t2421;
double t2426;
double t2393;
double t2395;
double t2406;
double t2435;
double t2439;
double t2442;
double t2492;
double t2496;
double t2510;
double t2528;
double t2555;
double t2557;
double t2566;
double t2605;
double t2610;
double t2613;
double t2621;
double t2625;
double t2627;
double t2635;
double t2645;
double t2647;
double t2652;
double t2674;
double t2681;
double t2689;
double t2691;
double t2705;
double t2710;
double t2721;
double t2741;
double t2750;
double t2755;
double t2820;
double t2824;
double t2828;
double t2837;
double t2839;
double t2842;
double t2846;
double t2871;
double t2872;
double t2878;
double t2903;
double t2906;
double t2919;
double t1962;
double t2015;
double t2028;
double t2050;
double t2219;
double t2223;
double t2963;
double t2967;
double t2969;
double t2982;
double t2985;
double t2990;
double t2255;
double t2262;
double t2272;
double t2338;
double t2344;
double t2345;
double t2998;
double t3000;
double t3003;
double t2424;
double t2428;
double t2432;
double t2454;
double t2465;
double t2481;
double t2514;
double t2531;
double t2545;
double t3030;
double t3031;
double t3035;
double t3049;
double t3051;
double t3056;
double t2583;
double t2594;
double t2599;
double t2631;
double t2640;
double t2642;
double t3064;
double t3069;
double t3072;
double t3080;
double t3093;
double t3102;
double t2661;
double t2664;
double t2670;
double t2717;
double t2736;
double t2737;
double t3115;
double t3116;
double t3123;
double t3137;
double t3138;
double t3142;
double t2773;
double t2779;
double t2802;
double t2845;
double t2852;
double t2866;
double t3150;
double t3151;
double t3154;
double t3158;
double t3159;
double t3160;
double t2890;
double t2892;
double t2896;
double t3169;
double t3172;
double t3176;
double t3182;
double t3186;
double t3195;
double t3239;
double t3242;
double t3248;
double t3280;
double t3284;
double t3287;
double t3296;
double t3299;
double t3303;
double t3308;
double t3310;
double t3312;
double t3316;
double t3317;
double t3325;
double t3334;
double t3335;
double t3337;
double t3341;
double t3343;
double t3344;
double t3354;
double t3355;
double t3359;
double t3365;
double t3370;
double t3371;
double t3378;
double t3379;
double t3382;
double t3386;
double t3389;
double t3392;
t2124 = Cos(var1[3]);
t2089 = Cos(var1[5]);
t2134 = Sin(var1[4]);
t2101 = Sin(var1[3]);
t2138 = Sin(var1[5]);
t328 = Cos(var1[6]);
t2109 = -1.*t2089*t2101;
t2149 = t2124*t2134*t2138;
t2160 = t2109 + t2149;
t2181 = t2124*t2089*t2134;
t2185 = t2101*t2138;
t2186 = t2181 + t2185;
t2213 = Sin(var1[6]);
t2244 = Cos(var1[7]);
t2249 = -1.*t2244;
t2251 = 1. + t2249;
t2258 = Sin(var1[7]);
t2238 = t328*t2160;
t2240 = t2186*t2213;
t2243 = t2238 + t2240;
t2324 = Cos(var1[4]);
t2413 = Cos(var1[8]);
t2416 = -1.*t2413;
t2421 = 1. + t2416;
t2426 = Sin(var1[8]);
t2393 = t2124*t2324*t2244;
t2395 = t2243*t2258;
t2406 = t2393 + t2395;
t2435 = t328*t2186;
t2439 = -1.*t2160*t2213;
t2442 = t2435 + t2439;
t2492 = Cos(var1[9]);
t2496 = -1.*t2492;
t2510 = 1. + t2496;
t2528 = Sin(var1[9]);
t2555 = t2413*t2406;
t2557 = t2442*t2426;
t2566 = t2555 + t2557;
t2605 = t2413*t2442;
t2610 = -1.*t2406*t2426;
t2613 = t2605 + t2610;
t2621 = Cos(var1[10]);
t2625 = -1.*t2621;
t2627 = 1. + t2625;
t2635 = Sin(var1[10]);
t2645 = -1.*t2528*t2566;
t2647 = t2492*t2613;
t2652 = t2645 + t2647;
t2674 = t2492*t2566;
t2681 = t2528*t2613;
t2689 = t2674 + t2681;
t2691 = Cos(var1[11]);
t2705 = -1.*t2691;
t2710 = 1. + t2705;
t2721 = Sin(var1[11]);
t2741 = t2635*t2652;
t2750 = t2621*t2689;
t2755 = t2741 + t2750;
t2820 = t2621*t2652;
t2824 = -1.*t2635*t2689;
t2828 = t2820 + t2824;
t2837 = Cos(var1[12]);
t2839 = -1.*t2837;
t2842 = 1. + t2839;
t2846 = Sin(var1[12]);
t2871 = -1.*t2721*t2755;
t2872 = t2691*t2828;
t2878 = t2871 + t2872;
t2903 = t2691*t2755;
t2906 = t2721*t2828;
t2919 = t2903 + t2906;
t1962 = -1.*t328;
t2015 = 1. + t1962;
t2028 = 0.135*t2015;
t2050 = 0. + t2028;
t2219 = -0.135*t2213;
t2223 = 0. + t2219;
t2963 = t2124*t2089;
t2967 = t2101*t2134*t2138;
t2969 = t2963 + t2967;
t2982 = t2089*t2101*t2134;
t2985 = -1.*t2124*t2138;
t2990 = t2982 + t2985;
t2255 = 0.135*t2251;
t2262 = 0.049*t2258;
t2272 = 0. + t2255 + t2262;
t2338 = -0.049*t2251;
t2344 = 0.135*t2258;
t2345 = 0. + t2338 + t2344;
t2998 = t328*t2969;
t3000 = t2990*t2213;
t3003 = t2998 + t3000;
t2424 = -0.049*t2421;
t2428 = -0.09*t2426;
t2432 = 0. + t2424 + t2428;
t2454 = -0.09*t2421;
t2465 = 0.049*t2426;
t2481 = 0. + t2454 + t2465;
t2514 = -0.049*t2510;
t2531 = -0.21*t2528;
t2545 = 0. + t2514 + t2531;
t3030 = t2324*t2244*t2101;
t3031 = t3003*t2258;
t3035 = t3030 + t3031;
t3049 = t328*t2990;
t3051 = -1.*t2969*t2213;
t3056 = t3049 + t3051;
t2583 = -0.21*t2510;
t2594 = 0.049*t2528;
t2599 = 0. + t2583 + t2594;
t2631 = -0.2707*t2627;
t2640 = 0.0016*t2635;
t2642 = 0. + t2631 + t2640;
t3064 = t2413*t3035;
t3069 = t3056*t2426;
t3072 = t3064 + t3069;
t3080 = t2413*t3056;
t3093 = -1.*t3035*t2426;
t3102 = t3080 + t3093;
t2661 = -0.0016*t2627;
t2664 = -0.2707*t2635;
t2670 = 0. + t2661 + t2664;
t2717 = 0.0184*t2710;
t2736 = -0.7055*t2721;
t2737 = 0. + t2717 + t2736;
t3115 = -1.*t2528*t3072;
t3116 = t2492*t3102;
t3123 = t3115 + t3116;
t3137 = t2492*t3072;
t3138 = t2528*t3102;
t3142 = t3137 + t3138;
t2773 = -0.7055*t2710;
t2779 = -0.0184*t2721;
t2802 = 0. + t2773 + t2779;
t2845 = -1.1135*t2842;
t2852 = 0.0216*t2846;
t2866 = 0. + t2845 + t2852;
t3150 = t2635*t3123;
t3151 = t2621*t3142;
t3154 = t3150 + t3151;
t3158 = t2621*t3123;
t3159 = -1.*t2635*t3142;
t3160 = t3158 + t3159;
t2890 = -0.0216*t2842;
t2892 = -1.1135*t2846;
t2896 = 0. + t2890 + t2892;
t3169 = -1.*t2721*t3154;
t3172 = t2691*t3160;
t3176 = t3169 + t3172;
t3182 = t2691*t3154;
t3186 = t2721*t3160;
t3195 = t3182 + t3186;
t3239 = t2324*t328*t2138;
t3242 = t2324*t2089*t2213;
t3248 = t3239 + t3242;
t3280 = -1.*t2244*t2134;
t3284 = t3248*t2258;
t3287 = t3280 + t3284;
t3296 = t2324*t2089*t328;
t3299 = -1.*t2324*t2138*t2213;
t3303 = t3296 + t3299;
t3308 = t2413*t3287;
t3310 = t3303*t2426;
t3312 = t3308 + t3310;
t3316 = t2413*t3303;
t3317 = -1.*t3287*t2426;
t3325 = t3316 + t3317;
t3334 = -1.*t2528*t3312;
t3335 = t2492*t3325;
t3337 = t3334 + t3335;
t3341 = t2492*t3312;
t3343 = t2528*t3325;
t3344 = t3341 + t3343;
t3354 = t2635*t3337;
t3355 = t2621*t3344;
t3359 = t3354 + t3355;
t3365 = t2621*t3337;
t3370 = -1.*t2635*t3344;
t3371 = t3365 + t3370;
t3378 = -1.*t2721*t3359;
t3379 = t2691*t3371;
t3382 = t3378 + t3379;
t3386 = t2691*t3359;
t3389 = t2721*t3371;
t3392 = t3386 + t3389;
p_output1[0]=0. + t2050*t2160 + t2186*t2223 + t2243*t2272 + 0.1305*(t2243*t2244 - 1.*t2124*t2258*t2324) + t2124*t2324*t2345 + t2406*t2432 + t2442*t2481 + t2545*t2566 + t2599*t2613 + t2642*t2652 + t2670*t2689 + t2737*t2755 + t2802*t2828 + t2866*t2878 + t2896*t2919 - 0.0216*(t2846*t2878 + t2837*t2919) - 1.1135*(t2837*t2878 - 1.*t2846*t2919) + var1[0];
p_output1[1]=0. + t2101*t2324*t2345 + t2050*t2969 + t2223*t2990 + t2272*t3003 + 0.1305*(-1.*t2101*t2258*t2324 + t2244*t3003) + t2432*t3035 + t2481*t3056 + t2545*t3072 + t2599*t3102 + t2642*t3123 + t2670*t3142 + t2737*t3154 + t2802*t3160 + t2866*t3176 + t2896*t3195 - 0.0216*(t2846*t3176 + t2837*t3195) - 1.1135*(t2837*t3176 - 1.*t2846*t3195) + var1[1];
p_output1[2]=0. + t2050*t2138*t2324 + t2089*t2223*t2324 - 1.*t2134*t2345 + t2272*t3248 + 0.1305*(t2134*t2258 + t2244*t3248) + t2432*t3287 + t2481*t3303 + t2545*t3312 + t2599*t3325 + t2642*t3337 + t2670*t3344 + t2737*t3359 + t2802*t3371 + t2866*t3382 + t2896*t3392 - 0.0216*(t2846*t3382 + t2837*t3392) - 1.1135*(t2837*t3382 - 1.*t2846*t3392) + var1[2];
}
#ifdef MATLAB_MEX_FILE
#include "mex.h"
/*
* Main function
*/
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
size_t mrows, ncols;
double *var1;
double *p_output1;
/* Check for proper number of arguments. */
if( nrhs != 1)
{
mexErrMsgIdAndTxt("MATLAB:MShaped:invalidNumInputs", "One input(s) required (var1).");
}
else if( nlhs > 1)
{
mexErrMsgIdAndTxt("MATLAB:MShaped:maxlhs", "Too many output arguments.");
}
/* The input must be a noncomplex double vector or scaler. */
mrows = mxGetM(prhs[0]);
ncols = mxGetN(prhs[0]);
if( !mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) ||
( !(mrows == 20 && ncols == 1) &&
!(mrows == 1 && ncols == 20)))
{
mexErrMsgIdAndTxt( "MATLAB:MShaped:inputNotRealVector", "var1 is wrong.");
}
/* Assign pointers to each input. */
var1 = mxGetPr(prhs[0]);
/* Create matrices for return arguments. */
plhs[0] = mxCreateDoubleMatrix((mwSize) 3, (mwSize) 1, mxREAL);
p_output1 = mxGetPr(plhs[0]);
/* Call the calculation subroutine. */
output1(p_output1,var1);
}
#else // MATLAB_MEX_FILE
#include "LeftToeJoint_mex.hh"
namespace SymExpression
{
void LeftToeJoint_mex_raw(double *p_output1, const double *var1)
{
// Call Subroutines
output1(p_output1, var1);
}
}
#endif // MATLAB_MEX_FILE
| 11,309 | 7,446 |
#include "Gwen/UnitTest/UnitTest.h"
#include "Gwen/Controls/ComboBox.h"
using namespace Gwen;
class ComboBox : public GUnit
{
public:
GWEN_CONTROL_INLINE(ComboBox, GUnit)
{
{
Gwen::Controls::ComboBox* combo = new Gwen::Controls::ComboBox(this);
combo->SetPos(50, 50);
combo->SetWidth(200);
combo->AddItem("Option One", "one");
combo->AddItem("Number Two", "two");
combo->AddItem("Door Three", "three");
combo->AddItem("Four Legs", "four");
combo->AddItem("Five Birds", "five");
combo->onSelection.Add(this, &ComboBox::OnComboSelect);
}
{
// Empty..
Gwen::Controls::ComboBox* combo = new Gwen::Controls::ComboBox(this);
combo->SetPos(50, 80);
combo->SetWidth(200);
}
{
// Empty..
Gwen::Controls::ComboBox* combo = new Gwen::Controls::ComboBox(this);
combo->SetPos(50, 110);
combo->SetWidth(200);
for (int i = 0; i < 500; i++)
{
combo->AddItem("Lots Of Options");
}
}
}
void OnComboSelect(Gwen::Controls::Base* pControl)
{
Gwen::Controls::ComboBox* combo = (Gwen::Controls::ComboBox*)pControl;
UnitPrint(Utility::Format("Combo Changed: %s",
combo->GetSelectedItem()->GetText().c_str()));
}
};
DEFINE_UNIT_TEST(ComboBox, "ComboBox");
| 1,517 | 490 |
/**
* <ORGANIZATION> = Jennifer Buehler
* <COPYRIGHT HOLDER> = Jennifer Buehler
*
* Copyright (c) 2016 Jennifer Buehler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* ------------------------------------------------------------------------------
**/
#include <ros/ros.h>
#include <urdf_traverser/UrdfTraverser.h>
#include <urdf_traverser/PrintModel.h>
#include <urdf_transform/ScaleModel.h>
#include <urdf_transform/JoinFixedLinks.h>
#include <urdf_transform/AlignRotationAxis.h>
#include <string>
using urdf_traverser::UrdfTraverser;
void printHelp(char * progName)
{
ROS_INFO_STREAM("Test tool for urdf transform.");
ROS_INFO_STREAM("Usage: " << progName << " <OP> <input-file> [<from-link>]");
ROS_INFO_STREAM("<OP>: The operation to perform. <print|scale|join|zaxis>");
ROS_INFO_STREAM("If <from-link> is specified, the URDF is processed from this link down instead of the root link.");
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "urdf_traverser_scale_model", ros::init_options::AnonymousName);
if (argc < 3)
{
printHelp(argv[0]);
return 0;
}
enum Operation {PRINT, SCALE, JOIN, ZAXIS};
Operation op;
std::string opArg = argv[1];
if (opArg == "print")
{
op = PRINT;
}
else if (opArg == "scale")
{
op = SCALE;
}
else if (opArg == "join")
{
op = JOIN;
}
else if (opArg == "zaxis")
{
op = ZAXIS;
}
else
{
printHelp(argv[0]);
ROS_ERROR_STREAM("Unkown operation: " << opArg);
return 1;
}
std::string inputFile = argv[2];
std::string fromLink;
if (argc > 3)
{
fromLink = argv[3];
}
ROS_INFO_STREAM("Traversing model from file " << inputFile << "...");
if (!fromLink.empty()) ROS_INFO_STREAM("Starting from link " << fromLink);
bool verbose = false;
ROS_INFO("Loading file...");
UrdfTraverser traverser;
if (!traverser.loadModelFromFile(inputFile))
{
ROS_ERROR_STREAM("Could not load file " << inputFile);
return 0;
}
switch (op)
{
case PRINT:
{
ROS_INFO("###### MODEL #####");
verbose = true;
traverser.printModel(verbose);
ROS_INFO("###### JOINT NAMES #####");
traverser.printJointNames(fromLink);
break;
}
case SCALE:
{
ROS_INFO("###### MODEL BEFORE #####");
verbose = true;
traverser.printModel(verbose);
urdf_transform::scaleModel(traverser, 2);
break;
}
case JOIN:
{
ROS_INFO("Join fixed links...");
if (!urdf_transform::joinFixedLinks(traverser, fromLink))
{
ROS_ERROR_STREAM("Could not join fixed links");
return 0;
}
ROS_INFO("$$$--- Joint names after fixed linked joining:");
traverser.printJointNames(fromLink);
break;
}
case ZAXIS:
{
verbose = true;
ROS_INFO("Align rotation axis...");
ROS_INFO("###### MODEL BEFORE #####");
traverser.printModel(verbose);
Eigen::Vector3d axis(0, 0, 1);
if (!urdf_transform::allRotationsToAxis(traverser, fromLink, axis))
{
ROS_ERROR_STREAM("Could not rotate axes");
return 0;
}
break;
}
default:
{
ROS_ERROR("Unknown operation.");
return 1;
}
}
if (op != PRINT)
{
ROS_INFO("### Model after processing:");
traverser.printModel(verbose);
}
return 0;
}
| 5,061 | 1,757 |
/*
Copyright 2016 Massachusetts Institute of Technology
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "client_query.h"
#include "mem_alloc.h"
#include "wl.h"
#include "table.h"
#include "ycsb_query.h"
#include "tpcc_query.h"
#include "pps_query.h"
/*************************************************/
// class Query_queue
/*************************************************/
void
Client_query_queue::init(Workload * h_wl) {
_wl = h_wl;
#if SERVER_GENERATE_QUERIES
if(ISCLIENT)
return;
size = g_thread_cnt;
#else
size = g_servers_per_client;
#endif
query_cnt = new uint64_t * [size];
for ( UInt32 id = 0; id < size; id ++) {
std::vector<BaseQuery*> new_queries(g_max_txn_per_part+4,NULL);
queries.push_back(new_queries);
query_cnt[id] = (uint64_t*)mem_allocator.align_alloc(sizeof(uint64_t));
}
next_tid = 0;
pthread_t * p_thds = new pthread_t[g_init_parallelism - 1];
for (UInt32 i = 0; i < g_init_parallelism - 1; i++) {
pthread_create(&p_thds[i], NULL, initQueriesHelper, this);
}
initQueriesHelper(this);
for (uint32_t i = 0; i < g_init_parallelism - 1; i++) {
pthread_join(p_thds[i], NULL);
}
}
void *
Client_query_queue::initQueriesHelper(void * context) {
((Client_query_queue*)context)->initQueriesParallel();
return NULL;
}
void
Client_query_queue::initQueriesParallel() {
UInt32 tid = ATOM_FETCH_ADD(next_tid, 1);
uint64_t request_cnt;
request_cnt = g_max_txn_per_part + 4;
uint32_t final_request;
if (tid == g_init_parallelism-1) {
final_request = request_cnt;
} else {
final_request = request_cnt / g_init_parallelism * (tid+1);
}
#if WORKLOAD == YCSB
YCSBQueryGenerator * gen = new YCSBQueryGenerator;
gen->init();
#elif WORKLOAD == TPCC
TPCCQueryGenerator * gen = new TPCCQueryGenerator;
#elif WORKLOAD == PPS
PPSQueryGenerator * gen = new PPSQueryGenerator;
#endif
#if SERVER_GENERATE_QUERIES
for ( UInt32 thread_id = 0; thread_id < g_thread_cnt; thread_id ++) {
for (UInt32 query_id = request_cnt / g_init_parallelism * tid; query_id < final_request; query_id ++) {
queries[thread_id][query_id] = gen->create_query(_wl,g_node_id);
}
}
#else
for ( UInt32 server_id = 0; server_id < g_servers_per_client; server_id ++) {
for (UInt32 query_id = request_cnt / g_init_parallelism * tid; query_id < final_request; query_id ++) {
queries[server_id][query_id] = gen->create_query(_wl,server_id+g_server_start_node); // --- test
// if((query_id + server_id) % 2 == 0){
// queries[server_id][query_id] = gen->gen_requests_zipf(server_id+g_server_start_node, _wl, RD);
// }else{
// queries[server_id][query_id] = gen->gen_requests_zipf(server_id+g_server_start_node, _wl, WR);
// }
}
}
#endif
}
bool
Client_query_queue::done() {
return false;
}
BaseQuery *
Client_query_queue::get_next_query(uint64_t server_id,uint64_t thread_id) {
assert(server_id < size);
uint64_t query_id = __sync_fetch_and_add(query_cnt[server_id], 1);
if(query_id > g_max_txn_per_part) {
__sync_bool_compare_and_swap(query_cnt[server_id],query_id+1,0);
query_id = __sync_fetch_and_add(query_cnt[server_id], 1);
}
BaseQuery * query = queries[server_id][query_id];
return query;
}
| 3,822 | 1,467 |
/*
* Copyright (c) 2015, msyksphinz
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the copyright holder nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdint.h>
#include <gmpxx.h>
#include <iostream>
#include <iomanip>
#include "inst_list_riscv.hpp"
#include "dec_utils_riscv.hpp"
#include "softfloat.h"
#include "riscv_pe_thread.hpp"
#include "inst_riscv.hpp"
#include "riscv_sysreg_impl.hpp"
#include "inst_ops.hpp"
#include "riscv_sysreg_bitdef.hpp"
uint32_t shuffle32_stage(uint32_t src, uint32_t maskL, uint32_t maskR, int N)
{
uint32_t x = src & ~(maskL | maskR);
x |= ((src << N) & maskL) | ((src >> N) & maskR);
return x;
}
uint32_t shfl32(uint32_t rs1, uint32_t rs2)
{
uint32_t x = rs1;
int shamt = rs2 & 15;
if (shamt & 8) x = shuffle32_stage(x, 0x00ff0000, 0x0000ff00, 8);
if (shamt & 4) x = shuffle32_stage(x, 0x0f000f00, 0x00f000f0, 4);
if (shamt & 2) x = shuffle32_stage(x, 0x30303030, 0x0c0c0c0c, 2);
if (shamt & 1) x = shuffle32_stage(x, 0x44444444, 0x22222222, 1);
return x;
}
uint32_t unshfl32(uint32_t rs1, uint32_t rs2)
{
uint32_t x = rs1;
int shamt = rs2 & 15;
if (shamt & 1) x = shuffle32_stage(x, 0x44444444, 0x22222222, 1);
if (shamt & 2) x = shuffle32_stage(x, 0x30303030, 0x0c0c0c0c, 2);
if (shamt & 4) x = shuffle32_stage(x, 0x0f000f00, 0x00f000f0, 4);
if (shamt & 8) x = shuffle32_stage(x, 0x00ff0000, 0x0000ff00, 8);
return x;
}
UDWord_t shuffle64_stage(UDWord_t src, UDWord_t maskL, UDWord_t maskR, int N)
{
UDWord_t x = src & ~(maskL | maskR);
x |= ((src << N) & maskL) | ((src >> N) & maskR);
return x;
}
UDWord_t shfl64(UDWord_t rs1_val, UDWord_t rs2_val)
{
UDWord_t x = rs1_val;
int shamt = rs2_val & 31;
if (shamt & 16) x = shuffle64_stage(x, 0x0000ffff00000000LL,
0x00000000ffff0000LL, 16);
if (shamt & 8) x = shuffle64_stage(x, 0x00ff000000ff0000LL,
0x0000ff000000ff00LL, 8);
if (shamt & 4) x = shuffle64_stage(x, 0x0f000f000f000f00LL,
0x00f000f000f000f0LL, 4);
if (shamt & 2) x = shuffle64_stage(x, 0x3030303030303030LL,
0x0c0c0c0c0c0c0c0cLL, 2);
if (shamt & 1) x = shuffle64_stage(x, 0x4444444444444444LL,
0x2222222222222222LL, 1);
return x;
}
UDWord_t unshfl64(UDWord_t rs1_val, UDWord_t rs2_val)
{
UDWord_t x = rs1_val;
int shamt = rs2_val & 31;
if (shamt & 1) x = shuffle64_stage(x, 0x4444444444444444LL,
0x2222222222222222LL, 1);
if (shamt & 2) x = shuffle64_stage(x, 0x3030303030303030LL,
0x0c0c0c0c0c0c0c0cLL, 2);
if (shamt & 4) x = shuffle64_stage(x, 0x0f000f000f000f00LL,
0x00f000f000f000f0LL, 4);
if (shamt & 8) x = shuffle64_stage(x, 0x00ff000000ff0000LL,
0x0000ff000000ff00LL, 8);
if (shamt & 16) x = shuffle64_stage(x, 0x0000ffff00000000LL,
0x00000000ffff0000LL, 16);
return x;
}
UDWord_t slo(UDWord_t rs1, UDWord_t rs2, int xlen)
{
int shamt = rs2 & (xlen - 1);
return ~(~rs1 << shamt);
}
void InstEnv::RISCV_INST_SLO (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = ~(~rs1_val << shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SRO (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = ~(~rs1_val >> shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_ROL (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = (rs1_val << shamt) | (rs1_val >> ((m_pe_thread->GetBitModeInt() - shamt) & (m_pe_thread->GetBitModeInt() - 1)));
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_ROR (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = (rs1_val >> shamt) | (rs1_val << ((m_pe_thread->GetBitModeInt() - shamt) & (m_pe_thread->GetBitModeInt() - 1)));
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBCLR (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
int shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = rs1_val & ~(UDWord_t(1) << shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBSET (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
int shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = rs1_val | (UDWord_t(1) << shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBINV (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
int shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = rs1_val ^ (UDWord_t(1) << shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBEXT (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
int shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = 1 & (rs1_val >> shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_GORC (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
DWord_t res = 0;
if (m_pe_thread->GetBitMode() == RiscvBitMode_t::Bit32) {
UWord_t x = rs1_val;
int shamt = rs2_val & 31;
if (shamt & 1) x |= ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >> 1);
if (shamt & 2) x |= ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >> 2);
if (shamt & 4) x |= ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >> 4);
if (shamt & 8) x |= ((x & 0x00FF00FF) << 8) | ((x & 0xFF00FF00) >> 8);
if (shamt & 16) x |= ((x & 0x0000FFFF) << 16) | ((x & 0xFFFF0000) >> 16);
res = x;
} else if (m_pe_thread->GetBitMode() == RiscvBitMode_t::Bit64) {
UDWord_t x = rs1_val;
int shamt = rs2_val & 63;
if (shamt & 1) x |= ((x & 0x5555555555555555LL) << 1) |
((x & 0xAAAAAAAAAAAAAAAALL) >> 1);
if (shamt & 2) x |= ((x & 0x3333333333333333LL) << 2) |
((x & 0xCCCCCCCCCCCCCCCCLL) >> 2);
if (shamt & 4) x |= ((x & 0x0F0F0F0F0F0F0F0FLL) << 4) |
((x & 0xF0F0F0F0F0F0F0F0LL) >> 4);
if (shamt & 8) x |= ((x & 0x00FF00FF00FF00FFLL) << 8) |
((x & 0xFF00FF00FF00FF00LL) >> 8);
if (shamt & 16) x |= ((x & 0x0000FFFF0000FFFFLL) << 16) |
((x & 0xFFFF0000FFFF0000LL) >> 16);
if (shamt & 32) x |= ((x & 0x00000000FFFFFFFFLL) << 32) |
((x & 0xFFFFFFFF00000000LL) >> 32);
res = x;
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_GREV (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t res = 0;
for (uint32_t i = 0; i < m_pe_thread->GetBitModeInt(); i++) {
int j = (i ^ rs2_val) & (m_pe_thread->GetBitModeInt()-1);
res |= ((rs1_val >> i) & 1) << j;
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SLOI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = ~(~rs1_val << shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SROI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t imm = ExtractBitField (inst_hex, 26, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
UDWord_t res = ~(~rs1_val >> shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_RORI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = (rs1_val >> shamt) | (rs1_val << ((m_pe_thread->GetBitModeInt() - shamt) & (m_pe_thread->GetBitModeInt() - 1)));
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBCLRI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
int shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = rs1_val & ~(UDWord_t(1) << shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBSETI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
int shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = rs1_val | (UDWord_t(1) << shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBINVI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
int shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = rs1_val ^ (UDWord_t(1) << shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBEXTI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
int shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = 1 & (rs1_val >> shamt);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_GORCI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
// int shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
DWord_t res = 0;
if (m_pe_thread->GetBitMode() == RiscvBitMode_t::Bit32) {
UWord_t x = rs1_val;
int shamt = imm & 31;
if (shamt & 1) x |= ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >> 1);
if (shamt & 2) x |= ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >> 2);
if (shamt & 4) x |= ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >> 4);
if (shamt & 8) x |= ((x & 0x00FF00FF) << 8) | ((x & 0xFF00FF00) >> 8);
if (shamt & 16) x |= ((x & 0x0000FFFF) << 16) | ((x & 0xFFFF0000) >> 16);
res = x;
} else if (m_pe_thread->GetBitMode() == RiscvBitMode_t::Bit64) {
UDWord_t x = rs1_val;
int shamt = imm & 63;
if (shamt & 1) x |= ((x & 0x5555555555555555LL) << 1) |
((x & 0xAAAAAAAAAAAAAAAALL) >> 1);
if (shamt & 2) x |= ((x & 0x3333333333333333LL) << 2) |
((x & 0xCCCCCCCCCCCCCCCCLL) >> 2);
if (shamt & 4) x |= ((x & 0x0F0F0F0F0F0F0F0FLL) << 4) |
((x & 0xF0F0F0F0F0F0F0F0LL) >> 4);
if (shamt & 8) x |= ((x & 0x00FF00FF00FF00FFLL) << 8) |
((x & 0xFF00FF00FF00FF00LL) >> 8);
if (shamt & 16) x |= ((x & 0x0000FFFF0000FFFFLL) << 16) |
((x & 0xFFFF0000FFFF0000LL) >> 16);
if (shamt & 32) x |= ((x & 0x00000000FFFFFFFFLL) << 32) |
((x & 0xFFFFFFFF00000000LL) >> 32);
res = x;
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_GREVI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
UDWord_t res = 0;
for (uint32_t i = 0; i < m_pe_thread->GetBitModeInt(); i++) {
int j = (i ^ imm) & (m_pe_thread->GetBitModeInt()-1);
res |= ((rs1_val >> i) & 1) << j;
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CMIX (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rs3_addr = ExtractR3Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t rs3_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs3_addr));
UDWord_t res = (rs1_val & rs2_val) | (rs3_val & ~rs2_val);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CMOV (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rs3_addr = ExtractR3Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t rs3_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs3_addr));
UDWord_t res = rs2_val ? rs1_val : rs3_val;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_FSL (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rs3_addr = ExtractR3Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t rs3_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs3_addr));
uint32_t shamt = rs2_val & (2*m_pe_thread->GetBitModeInt() - 1);
UDWord_t A = rs1_val, B = rs3_val;
if (shamt >= m_pe_thread->GetBitModeInt()) {
shamt -= m_pe_thread->GetBitModeInt();
A = rs3_val;
B = rs1_val;
}
UDWord_t res = shamt ? (A << shamt) | (B >> (m_pe_thread->GetBitModeInt()-shamt)) : A;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_FSR (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rs3_addr = ExtractR3Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t rs3_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs3_addr));
uint32_t shamt = rs2_val & (2*m_pe_thread->GetBitModeInt() - 1);
UDWord_t A = rs1_val, B = rs3_val;
if (shamt >= m_pe_thread->GetBitModeInt()) {
shamt -= m_pe_thread->GetBitModeInt();
A = rs3_val;
B = rs1_val;
}
UDWord_t res = shamt ? (A >> shamt) | (B << (m_pe_thread->GetBitModeInt()-shamt)) : A;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_FSRI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs3_addr = ExtractR3Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs3_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs3_addr));
UDWord_t imm = ExtractBitField (inst_hex, 25, 20);
uint32_t shamt = imm & (2 * m_pe_thread->GetBitModeInt() - 1);
UDWord_t A = rs1_val, B = rs3_val;
if (shamt >= m_pe_thread->GetBitModeInt()) {
shamt -= m_pe_thread->GetBitModeInt();
A = rs3_val;
B = rs1_val;
}
UDWord_t res = shamt ? (A >> shamt) | (B << (m_pe_thread->GetBitModeInt()-shamt)) : A;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CLZ (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t res = m_pe_thread->GetBitModeInt();
for (uint32_t count = 0; count < m_pe_thread->GetBitModeInt(); count++) {
if ((rs1_val << count) >> (m_pe_thread->GetBitModeInt() - 1)) {
res = count;
break;
}
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CTZ (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t res = m_pe_thread->GetBitModeInt();
for (uint32_t count = 0; count < m_pe_thread->GetBitModeInt(); count++) {
if ((rs1_val >> count) & 1) {
res = count;
break;
}
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_PCNT (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
int count = 0;
for (uint32_t index = 0; index < m_pe_thread->GetBitModeInt(); index++)
count += (rs1_val >> index) & 1;
DWord_t res = count;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_BMATFLIP (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t x = rs1_val;
x = shfl64(x, 31);
x = shfl64(x, 31);
x = shfl64(x, 31);
DWord_t res = x;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SEXT_B (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t res = DWord_t(rs1_val << (m_pe_thread->GetBitModeInt()-8)) >> (m_pe_thread->GetBitModeInt()-8);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SEXT_H (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t res = DWord_t(rs1_val << (m_pe_thread->GetBitModeInt()-16)) >> (m_pe_thread->GetBitModeInt()-16);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CRC32_B (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->ReadGReg<DWord_t> (rs1_addr);
UDWord_t res = m_pe_thread->crc32(rs1_val, 8);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CRC32_H (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->ReadGReg<DWord_t> (rs1_addr);
UDWord_t res = m_pe_thread->crc32(rs1_val, 16);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CRC32_W (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
DWord_t rs1_val = m_pe_thread->ReadGReg<DWord_t> (rs1_addr);
UDWord_t res = m_pe_thread->crc32(rs1_val, 32);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CRC32_D (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
DWord_t rs1_val = m_pe_thread->ReadGReg<DWord_t> (rs1_addr);
DWord_t res = m_pe_thread->crc32(rs1_val, 64);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CRC32C_B (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->ReadGReg<DWord_t> (rs1_addr);
UDWord_t res = m_pe_thread->crc32_c(rs1_val, 8);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CRC32C_H (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->ReadGReg<DWord_t> (rs1_addr);
UDWord_t res = m_pe_thread->crc32_c(rs1_val, 16);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CRC32C_W (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->ReadGReg<DWord_t> (rs1_addr);
UDWord_t res = m_pe_thread->crc32_c(rs1_val, 32);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CRC32C_D (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->ReadGReg<UDWord_t> (rs1_addr);
UDWord_t res = m_pe_thread->crc32_c(rs1_val, 64);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CLMUL (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t res = 0;
for (uint32_t i = 0; i < m_pe_thread->GetBitModeInt(); i++)
if ((rs2_val >> i) & 1)
res ^= rs1_val << i;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CLMULR (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t res = 0;
for (uint32_t i = 0; i < m_pe_thread->GetBitModeInt(); i++)
if ((rs2_val >> i) & 1)
res ^= rs1_val >> (m_pe_thread->GetBitModeInt()-i-1);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CLMULH (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t res = 0;
for (uint32_t i = 1; i < m_pe_thread->GetBitModeInt(); i++)
if ((rs2_val >> i) & 1)
res ^= rs1_val >> (m_pe_thread->GetBitModeInt()-i);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SHFL (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
if (m_pe_thread->GetBitMode() == RiscvBitMode_t::Bit32) {
UDWord_t res = shfl32(rs1_val, rs2_val);
m_pe_thread->WriteGReg<Word_t> (rd_addr, res);
} else {
UDWord_t res = shfl64(rs1_val, rs2_val);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
}
void InstEnv::RISCV_INST_UNSHFL (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
if (m_pe_thread->GetBitMode() == RiscvBitMode_t::Bit32) {
UDWord_t res = unshfl32(rs1_val, rs2_val);
m_pe_thread->WriteGReg<Word_t> (rd_addr, res);
} else {
UDWord_t res = unshfl64(rs1_val, rs2_val);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
}
void InstEnv::RISCV_INST_BDEP (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t res = 0;
for (uint32_t i = 0, j = 0; i < m_pe_thread->GetBitModeInt(); i++)
if ((rs2_val >> i) & 1) {
if ((rs1_val >> j) & 1)
res |= UDWord_t(1) << i;
j++;
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_BEXT (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t res = 0;
for (uint32_t i = 0, j = 0; i < m_pe_thread->GetBitModeInt(); i++)
if ((rs2_val >> i) & 1) {
if ((rs1_val >> i) & 1)
res |= UDWord_t(1) << j;
j++;
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_PACK (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t lower = (rs1_val << m_pe_thread->GetBitModeInt()/2) >> m_pe_thread->GetBitModeInt()/2;
UDWord_t upper = rs2_val << m_pe_thread->GetBitModeInt()/2;
UDWord_t res = lower | upper;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_PACKU (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t lower = rs1_val >> m_pe_thread->GetBitModeInt()/2;
UDWord_t upper = (rs2_val >> m_pe_thread->GetBitModeInt()/2) << m_pe_thread->GetBitModeInt()/2;
UDWord_t res = lower | upper;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
UDWord_t bmatflip(UDWord_t rs1)
{
UDWord_t x = rs1;
x = shfl64(x, 31);
x = shfl64(x, 31);
x = shfl64(x, 31);
return x;
}
void InstEnv::RISCV_INST_BMATOR (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
// transpose of rs2
UDWord_t rs2t = bmatflip(rs2_val);
uint8_t u[8]; // rows of rs1
uint8_t v[8]; // cols of rs2
for (int i = 0; i < 8; i++) {
u[i] = rs1_val >> (i*8);
v[i] = rs2t >> (i*8);
}
UDWord_t res = 0;
for (int i = 0; i < 64; i++) {
if ((u[i / 8] & v[i % 8]) != 0)
res |= 1LL << i;
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
UDWord_t pcnt(UDWord_t rs1, unsigned int xlen)
{
int count = 0;
for (uint32_t index = 0; index < xlen; index++)
count += (rs1 >> index) & 1;
return count;
}
void InstEnv::RISCV_INST_BMATXOR (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
// transpose of rs2
UDWord_t rs2t = bmatflip(rs2_val);
uint8_t u[8]; // rows of rs1
uint8_t v[8]; // cols of rs2
for (int i = 0; i < 8; i++) {
u[i] = rs1_val >> (i*8);
v[i] = rs2t >> (i*8);
}
UDWord_t res = 0;
for (int i = 0; i < 64; i++) {
if (pcnt(u[i / 8] & v[i % 8], m_pe_thread->GetBitModeInt()) & 1)
res |= 1LL << i;
}
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_PACKH (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t lower = rs1_val & 255;
UDWord_t upper = (rs2_val & 255) << 8;
UDWord_t res = lower | upper;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_BFP (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t cfg = rs2_val >> (m_pe_thread->GetBitModeInt()/2);
if ((cfg >> 30) == 2)
cfg = cfg >> 16;
int len = (cfg >> 8) & (m_pe_thread->GetBitModeInt()/2-1);
int off = cfg & (m_pe_thread->GetBitModeInt()-1);
len = len ? len : m_pe_thread->GetBitModeInt()/2;
UDWord_t mask = slo(0, len, m_pe_thread->GetBitModeInt()) << off;
UDWord_t data = rs2_val << off;
DWord_t res = (data & mask) | (rs1_val & ~mask);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SHFLI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 25, 20);
if (m_pe_thread->GetBitMode() == RiscvBitMode_t::Bit32) {
UDWord_t res = shfl32(rs1_val, imm);
m_pe_thread->WriteGReg<Word_t> (rd_addr, res);
} else {
UDWord_t res = shfl64(rs1_val, imm);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
}
void InstEnv::RISCV_INST_UNSHFLI (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 25, 20);
if (m_pe_thread->GetBitMode() == RiscvBitMode_t::Bit32) {
UDWord_t res = unshfl32(rs1_val, imm);
m_pe_thread->WriteGReg<Word_t> (rd_addr, res);
} else {
UDWord_t res = unshfl64(rs1_val, imm);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
}
void InstEnv::RISCV_INST_ADDIWU (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 25, 20);
UDWord_t result64 = rs1_val + imm;
UWord_t res = (uint32_t)result64;
m_pe_thread->WriteGReg<Word_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_ADDWU (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t result64 = rs1_val + rs2_val;
UWord_t res = (uint32_t)result64;
m_pe_thread->WriteGReg<Word_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SUBWU (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t result64 = rs1_val - rs2_val;
UWord_t res = (uint32_t)result64;
m_pe_thread->WriteGReg<Word_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_ADDU_W (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t rs2u = (uint32_t)rs2_val;
UDWord_t res = rs1_val + rs2u;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SUBU_W (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
UDWord_t rs2_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs2_addr));
UDWord_t rs2u = (uint32_t)rs2_val;
UDWord_t res = rs1_val - rs2u;
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SLOW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
Word_t res_32 = ~(~rs1_val << shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SROW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = ~(~rs1_val >> shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_ROLW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = (rs1_val << shamt) | (rs1_val >> ((m_pe_thread->GetBitModeInt() - shamt) & (m_pe_thread->GetBitModeInt() - 1)));
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_RORW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = (rs1_val >> shamt) | (rs1_val << ((m_pe_thread->GetBitModeInt() - shamt) & (m_pe_thread->GetBitModeInt() - 1)));
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SH1ADDU_W (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = (rs1_val << 1) + rs2_val;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SH2ADDU_W (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
Word_t res_32 = (rs1_val << 2) + rs2_val;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SH3ADDU_W (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
Word_t res_32 = (rs1_val << 3) + rs2_val;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBCLRW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
Word_t res_32 = rs1_val & ~(UWord_t(1) << shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBSETW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
Word_t res_32 = rs1_val | (UWord_t(1) << shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBINVW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
Word_t res_32 = rs1_val ^ (UWord_t(1) << shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBEXTW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
Word_t res_32 = 1 & (rs1_val >> shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_GORCW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
Word_t res_32 = 0;
uint32_t x = rs1_val;
uint32_t shamt = rs2_val & (m_pe_thread->GetBitModeInt() - 1);
if (shamt & 1) x |= ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >> 1);
if (shamt & 2) x |= ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >> 2);
if (shamt & 4) x |= ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >> 4);
if (shamt & 8) x |= ((x & 0x00FF00FF) << 8) | ((x & 0xFF00FF00) >> 8);
if (shamt & 16) x |= ((x & 0x0000FFFF) << 16) | ((x & 0xFFFF0000) >> 16);
res_32 = x;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_GREVW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = 0;
for (uint32_t i = 0; i < m_pe_thread->GetBitModeInt(); i++) {
int j = (i ^ rs2_val) & (m_pe_thread->GetBitModeInt()-1);
res_32 |= ((rs1_val >> i) & 1) << j;
}
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SLOIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UDWord_t rs1_val = m_pe_thread->SExtXlen (m_pe_thread->ReadGReg<UDWord_t> (rs1_addr));
DWord_t imm = ExtractBitField (inst_hex, 24, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
Word_t res_32 = ~(~rs1_val << shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SROIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
DWord_t imm = ExtractBitField (inst_hex, 24, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = ~(~rs1_val >> shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_RORIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
DWord_t imm = ExtractBitField (inst_hex, 24, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = (rs1_val >> shamt) | (rs1_val << ((m_pe_thread->GetBitModeInt() - shamt) & (m_pe_thread->GetBitModeInt() - 1)));
DWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBCLRIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<Word_t> (rs1_addr);
DWord_t imm = ExtractBitField (inst_hex, 26, 20);
int shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = rs1_val & ~(UWord_t(1) << shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBSETIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<Word_t> (rs1_addr);
DWord_t imm = ExtractBitField (inst_hex, 24, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = rs1_val | (UWord_t(1) << shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SBINVIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<Word_t> (rs1_addr);
DWord_t imm = ExtractBitField (inst_hex, 24, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = rs1_val ^ (UWord_t(1) << shamt);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_GORCIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<Word_t> (rs1_addr);
DWord_t imm = ExtractBitField (inst_hex, 24, 20);
uint32_t shamt = imm & (m_pe_thread->GetBitModeInt() - 1);
UWord_t res_32 = 0;
UWord_t x = rs1_val;
if (shamt & 1) x |= ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >> 1);
if (shamt & 2) x |= ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >> 2);
if (shamt & 4) x |= ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >> 4);
if (shamt & 8) x |= ((x & 0x00FF00FF) << 8) | ((x & 0xFF00FF00) >> 8);
if (shamt & 16) x |= ((x & 0x0000FFFF) << 16) | ((x & 0xFFFF0000) >> 16);
res_32 = x;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_GREVIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<Word_t> (rs1_addr);
DWord_t imm = ExtractBitField (inst_hex, 24, 20);
UWord_t res_32 = 0;
for (uint32_t i = 0; i < m_pe_thread->GetBitModeInt(); i++) {
int j = (i ^ imm) & (m_pe_thread->GetBitModeInt()-1);
res_32 |= ((rs1_val >> i) & 1) << j;
}
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_FSLW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rs3_addr = ExtractR3Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t rs3_val = m_pe_thread->ReadGReg<UWord_t> (rs3_addr);
uint32_t actual_xlen = 32;
uint32_t shamt = rs2_val & (2 * actual_xlen - 1);
UWord_t A = rs1_val, B = rs3_val;
if (shamt >= actual_xlen) {
shamt -= actual_xlen;
A = rs3_val;
B = rs1_val;
}
UWord_t res_32 = shamt ? (A << shamt) | (B >> (actual_xlen-shamt)) : A;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_FSRW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rs3_addr = ExtractR3Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs3_val = m_pe_thread->ReadGReg<UWord_t> (rs3_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
uint32_t actual_xlen = 32;
uint32_t shamt = rs2_val & ( 2 *actual_xlen - 1);
UDWord_t A = rs1_val, B = rs3_val;
if (shamt >= actual_xlen) {
shamt -= actual_xlen;
A = rs3_val;
B = rs1_val;
}
UWord_t res_32 = shamt ? (A >> shamt) | (B << (32-shamt)) : A;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_FSRIW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs3_addr = ExtractR3Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs3_val = m_pe_thread->ReadGReg<UWord_t> (rs3_addr);
UWord_t imm = ExtractBitField (inst_hex, 24, 20);
uint32_t actual_xlen = 32;
uint32_t shamt = imm & (2*actual_xlen - 1);
UWord_t A = rs1_val, B = rs3_val;
if (shamt >= actual_xlen) {
shamt -= actual_xlen;
A = rs3_val;
B = rs1_val;
}
UWord_t res_32 = shamt ? (A >> shamt) | (B << (32-shamt)) : A;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CLZW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t res_32 = 32;
for (int count = 0; count < 32; count++) {
if ((rs1_val << count) >> 31) {
res_32 = count;
break;
}
}
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CTZW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
Word_t res_32 = 32;
for (int count = 0; count < 32; count++) {
if ((rs1_val >> count) & 1) {
res_32 = count;
break;
}
}
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_PCNTW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
int count = 0;
for (int index = 0; index < 32; index++)
count += (rs1_val >> index) & 1;
Word_t res_32 = count;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CLMULW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = 0;
for (int i = 0; i < 32; i++)
if ((rs2_val >> i) & 1)
res_32 ^= rs1_val << i;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CLMULRW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = 0;
for (int i = 0; i < 32; i++)
if ((rs2_val >> i) & 1)
res_32 ^= rs1_val >> (32-i-1);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_CLMULHW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = 0;
for (int i = 1; i < 32; i++)
if ((rs2_val >> i) & 1)
res_32 ^= rs1_val >> (32-i);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_SHFLW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = shfl32(rs1_val, rs2_val);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_UNSHFLW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = unshfl32(rs1_val, rs2_val);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_BDEPW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = 0;
for (int i = 0, j = 0; i < 32; i++)
if ((rs2_val >> i) & 1) {
if ((rs1_val >> j) & 1)
res_32 |= UWord_t(1) << i;
j++;
}
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_BEXTW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t res_32 = 0;
for (int i = 0, j = 0; i < 32; i++)
if ((rs2_val >> i) & 1) {
if ((rs1_val >> i) & 1)
res_32 |= UWord_t(1) << j;
j++;
}
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_PACKW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t lower = (rs1_val << 32/2) >> 32/2;
UWord_t upper = rs2_val << 32/2;
UWord_t res_32 = lower | upper;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_PACKUW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t lower = rs1_val >> 32/2;
UWord_t upper = (rs2_val >> 32/2) << 32/2;
UWord_t res_32 = lower | upper;
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
void InstEnv::RISCV_INST_BFPW (InstWord_t inst_hex)
{
RegAddr_t rs1_addr = ExtractR1Field (inst_hex);
RegAddr_t rs2_addr = ExtractR2Field (inst_hex);
RegAddr_t rd_addr = ExtractRDField (inst_hex);
UWord_t rs1_val = m_pe_thread->ReadGReg<UWord_t> (rs1_addr);
UWord_t rs2_val = m_pe_thread->ReadGReg<UWord_t> (rs2_addr);
UWord_t cfg = rs2_val >> (32/2);
if ((cfg >> 30) == 2)
cfg = cfg >> 16;
int len = (cfg >> 8) & (32/2-1);
int off = cfg & (32-1);
len = len ? len : 32/2;
UWord_t mask = slo(0, len, 32) << off;
UWord_t data = rs2_val << off;
Word_t res_32 = (data & mask) | (rs1_val & ~mask);
UDWord_t res = ExtendSign(res_32, 31);
m_pe_thread->WriteGReg<UDWord_t> (rd_addr, res);
}
| 60,623 | 29,818 |
class GVAR(deleteMarkerSettingsSubCategory): GVAR(moduleSubCategory) {
displayName = CSTRING(Attributes_deleteMarkerSettingsSubCategory);
property = QGVAR(deleteMarkerSettingsSubCategory);
};
#ifndef MODULE_DELETEMARKER
#define DELETEMARKER_COND ((_this getVariable QQGVAR(deleteMarker)) isEqualTo true)
class GVAR(deleteMarker): GVAR(dynamicCheckbox) {
displayName = CSTRING(Attributes_deleteMarker);
tooltip = CSTRING(Attributes_deleteMarker_tooltip);
property = QGVAR(deleteMarker);
defaultValue = "false";
ATTRIBUTE_LOCAL;
};
#else
#define DELETEMARKER_COND (true)
#endif
class GVAR(deleteMarkerName): GVAR(dynamicEdit) {
displayName = CSTRING(Attributes_deleteMarkerName);
tooltip = CSTRING(Attributes_deleteMarkerName_tooltip);
GVAR(description) = CSTRING(Attributes_deleteMarkerName_desc);
property = QGVAR(deleteMarkerName);
defaultValue = "''";
#ifndef MODULE_DELETEMARKER
GVAR(conditionActive) = QUOTE(DELETEMARKER_COND);
#endif
ATTRIBUTE_LOCAL;
};
#undef DELETEMARKER_COND
#ifdef MODULE_DELETEMARKER
#undef MODULE_DELETEMARKER
#endif
| 1,153 | 396 |
#include "getbackpwd.h"
#include "ui_getbackpwd.h"
#include <QMessageBox>
QString userNameGet;
Getbackpwd::Getbackpwd(QWidget *parent) :
QWidget(parent),
ui(new Ui::Getbackpwd)
{
ui->setupUi(this);
setWindowTitle("找回密码");
connect( ui ->yes_btn, SIGNAL(clicked()), this,SLOT( judgeEmpty() ) );
}
Getbackpwd::~Getbackpwd()
{
delete ui;
}
void Getbackpwd::toReset(){
qDebug() << "in toReset" << endl;
resetPassword = new Resetpassword();
resetPassword -> show();
hide();
}
void Getbackpwd::judgeEmpty(){
userNameGet = ui -> mail_le -> text();
if( userNameGet.isEmpty() ){
QMessageBox::warning(this, tr("警告"),tr("输入为空"),tr("关闭"));
}
else{
if ( judgeExist() == true)
toReset();
}
}
bool Getbackpwd::judgeExist(){
//数据库:判断userGet用户名是否存在,userNameNew
bool isExist = true;
if (isExist == true){
return true;
}
else{
ui ->mail_le->setToolTip(tr("用户名不存在"));
return false;
}
}
| 1,006 | 400 |
/*
* Copyright (c) 2019 Nobuyuki Umetani
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <cmath>
#include <climits>
#if defined(_WIN32) // windows
# define NOMINMAX // to remove min,max macro
# include <windows.h> // should be before glfw3.h
#endif
#define GL_SILENCE_DEPRECATION
#include <GLFW/glfw3.h>
#include "delfem2/cam_projection.h"
#include "delfem2/cam_modelview.h"
#include "delfem2/vec3.h"
#include "delfem2/mshmisc.h"
#include "delfem2/gridcube.h"
#include "delfem2/glfw/viewer3.h"
#include "delfem2/glfw/util.h"
#include "delfem2/opengl/old/funcs.h"
#include "delfem2/opengl/old/gridcube.h"
#ifndef M_PI
# define M_PI 3.141592653589793
#endif
namespace dfm2 = delfem2;
// -----------------------------------------
int main() {
// -------------
class CViewer_CubeGrid : public dfm2::glfw::CViewer3 {
public:
CViewer_CubeGrid() : CViewer3(2.0) {
aCubeGrid.emplace_back(0, 0, 0);
org = dfm2::CVec3d(0, 0, 0);
}
void mouse_press(const float src[3], const float dir[3]) override {
dfm2::CVec3d offsym(0, 0, 0);
if (imode_sym == 2) { offsym.p[2] = -elen * 0.5; }
double src_pick0[3] = {src[0], src[1], src[2]};
double dir_pick0[3] = {dir[0], dir[1], dir[2]};
double offsym0[3];
offsym.CopyTo(offsym0);
Pick_CubeGrid(
icube_picked, iface_picked,
src_pick0, dir_pick0, elen, offsym0, aCubeGrid);
if (edit_mode == EDIT_ADD) {
int ivx1, ivy1, ivz1;
Adj_CubeGrid(
ivx1, ivy1, ivz1,
icube_picked, iface_picked, aCubeGrid);
Add_CubeGrid(aCubeGrid, ivx1, ivy1, ivz1);
if (imode_sym == 1) { Add_CubeGrid(aCubeGrid, ivx1, ivy1, -ivz1 - 1); }
if (imode_sym == 2) { Add_CubeGrid(aCubeGrid, ivx1, ivy1, -ivz1); }
}
if (edit_mode == EDIT_DELETE) {
int ivx1 = aCubeGrid[icube_picked].ivx;
int ivy1 = aCubeGrid[icube_picked].ivy;
int ivz1 = aCubeGrid[icube_picked].ivz;
Del_CubeGrid(aCubeGrid, ivx1, ivy1, ivz1);
if (imode_sym == 1) { Del_CubeGrid(aCubeGrid, ivx1, ivy1, -ivz1 - 1); }
if (imode_sym == 2) { Del_CubeGrid(aCubeGrid, ivx1, ivy1, -ivz1); }
}
}
void key_press(
int key,
[[maybe_unused]] int mods) override {
if (key == GLFW_KEY_A) {
glfwSetWindowTitle(this->window, "Edit Mode: Add");
edit_mode = EDIT_ADD;
}
if (key == GLFW_KEY_D) {
glfwSetWindowTitle(this->window, "Edit Mode: Delete");
edit_mode = EDIT_DELETE;
}
}
void Draw() const {
dfm2::CVec3d offsym(0, 0, 0);
if (imode_sym == 2) { offsym.p[2] = -elen * 0.5; }
for (unsigned int ic = 0; ic < aCubeGrid.size(); ++ic) {
delfem2::opengl::Draw_CubeGrid(
ic == icube_picked, iface_picked,
elen, org + offsym, aCubeGrid[ic]);
}
}
public:
int imode_sym = 2;
std::vector<dfm2::CCubeGrid> aCubeGrid;
const double elen = 1.0;
dfm2::CVec3d org;
unsigned int icube_picked = UINT_MAX;
int iface_picked = -1;
enum EDIT_MODE {
EDIT_NONE,
EDIT_ADD,
EDIT_DELETE,
};
EDIT_MODE edit_mode = EDIT_ADD;
} viewer;
//
dfm2::glfw::InitGLOld();
viewer.OpenWindow();
delfem2::opengl::setSomeLighting();
while (!glfwWindowShouldClose(viewer.window)) {
viewer.DrawBegin_oldGL();
viewer.Draw();
glfwSwapBuffers(viewer.window);
glfwPollEvents();
}
glfwDestroyWindow(viewer.window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
| 3,630 | 1,537 |
#include <iostream>
using namespace std;
class Node {
public:
int value;
Node* next;
Node(int i) { value = i; next = nullptr; }
Node() { next = nullptr; }
};
class LinkedList {
public:
Node* head;
//Node* tail;
LinkedList() { head = nullptr; }
LinkedList(int m, int n);//You can use code from class lectures for this constructor.
void print();//You can use code from class lecture for print.
//***************************************************************************************************
//implement the following member functions group and bubbleSort:
void group();
/*
Group all occurrences of the same numbers together according to the order of appearance.
For a list with values
7 6 12 4 33 12 6 6 7 ,
after grouping, it becomes
7 7 6 6 6 12 12 4 33
Note that in the original sequence, 7 appears before 6 before 12 before 4 before 33.
You are only allowed to change "next" of a node, but not "value."
Do not introduce additional functions.
In-place implementation is required. External structures, such as arrays, are not allowed.
For example, you are not allowed to copy linked list values to outside, and then process the data and copy them
back to linked list.
*/
void bubbleSort();
//you are allowed change both value and next for bubbleSort.
//Like function group, you are not allowed to use any external structures, such as arrays, to help.
//No extra functions allowed
};
LinkedList::LinkedList(int n, int m) {
head = nullptr;
for (int i = 0; i < n; ++i) {
Node* p1 = new Node{ rand() % m };
p1->next = head;
head = p1;
}
}
void LinkedList::print() {
Node* p1{ head };
while (p1) {//while (p1 != nullptr)
cout << p1->value << " ";
p1 = p1->next;
}
}
void LinkedList::group() {
if (!head || !head->next || !head->next->next) {
return;
}
/*Node* pre = head->next->next, *p4 = pre->next, *p4nx = p4->next, *cur = head->next;
head->next = p4;
p4->next = cur;
pre->next = p4nx;*/
Node* p = head;
int num = p->value;
do{
Node* cur = p->next;
while (cur != nullptr && cur->value == p->value) {
p = p->next;
cur = cur->next;
}
Node* change = cur;
if (cur == nullptr) {
break;
}
while ( cur->next != nullptr) {
if (cur->next->value == num) {
Node* last = cur->next->next;
p ->next = cur->next;
cur->next->next = change;
cur->next = last;
p = p ->next;
}
else {
cur = cur->next;
}
}
p = change;
num = p ->value;
if (p ->next == nullptr) {
break;
}
} while (p ->next->next != nullptr || p ->next != nullptr);
}
void LinkedList::bubbleSort() {
if (!head || !head->next) {
return;
}
Node* cur{ head }, * last{ nullptr };
while (last != head->next) {
while (cur->next != last) {
if (cur->value > cur->next->value) {
swap(cur->value, cur->next->value);
}
cur = cur->next;
}
last = cur;
cur = head;
}
/*int swaped =1;
while (swaped) {
Node* p1 = head;
swaped = 0;
while (p1->next != nullptr) {
if (p1 -> value > p1->next->value) {
swap(p1->value, p1->next->value);
swaped = 1;
}
p1 = p1->next;
}
}
*/
}
int main() {//During grading, different cases will be used.
LinkedList L1(50,20);
L1.print();
cout << endl;
L1.group();
L1.print();
cout << endl;
LinkedList L2(50, 25);
L2.print();
cout << endl;
L2.bubbleSort();
L2.print();
return 0;
} | 3,394 | 1,382 |
#include "duckdb/optimizer/filter_pushdown.hpp"
#include "duckdb/planner/operator/logical_filter.hpp"
#include "duckdb/planner/operator/logical_get.hpp"
#include "duckdb/storage/data_table.hpp"
namespace duckdb {
using namespace std;
unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperator> op) {
assert(op->type == LogicalOperatorType::GET);
auto &get = (LogicalGet &)*op;
if (!get.tableFilters.empty()) {
if (!filters.empty()) {
//! We didn't managed to push down all filters to table scan
auto logicalFilter = make_unique<LogicalFilter>();
for (auto &f : filters) {
logicalFilter->expressions.push_back(move(f->filter));
}
logicalFilter->children.push_back(move(op));
return move(logicalFilter);
} else {
return op;
}
}
//! FIXME: We only need to skip if the index is in the column being filtered
if (!get.table || !get.table->storage->info->indexes.empty()) {
//! now push any existing filters
if (filters.empty()) {
//! no filters to push
return op;
}
auto filter = make_unique<LogicalFilter>();
for (auto &f : filters) {
filter->expressions.push_back(move(f->filter));
}
filter->children.push_back(move(op));
return move(filter);
}
PushFilters();
vector<unique_ptr<Filter>> filtersToPushDown;
get.tableFilters = combiner.GenerateTableScanFilters(
[&](unique_ptr<Expression> filter) {
auto f = make_unique<Filter>();
f->filter = move(filter);
f->ExtractBindings();
filtersToPushDown.push_back(move(f));
},
get.column_ids);
for (auto &f : get.tableFilters) {
f.column_index = get.column_ids[f.column_index];
}
GenerateFilters();
for (auto &f : filtersToPushDown) {
get.expressions.push_back(move(f->filter));
}
if (!filters.empty()) {
//! We didn't managed to push down all filters to table scan
auto logicalFilter = make_unique<LogicalFilter>();
for (auto &f : filters) {
logicalFilter->expressions.push_back(move(f->filter));
}
logicalFilter->children.push_back(move(op));
return move(logicalFilter);
}
return op;
}
} // namespace duckdb
| 2,108 | 780 |
#include <stdlib.h>
#include <iostream>
#include <thread>
#include <string>
#include <cmath>
#include <inttypes.h>
#include <boost/tr1/random.hpp>
#include "utils.h"
#include "WordEmbed.h"
#define EXP_TABLE_SIZE 1000
#define MAX_EXP 6
#define MAX_CODE_LENGTH 40
#define MAX_SENTENCE_LENGTH 1000
class Word2Vec : public WordEmbed {
private:
unsigned int layer1_size;
int window;
real sample;
int hs, negative;
unsigned int num_threads;
unsigned int iter;
real alpha;
unsigned int classes;
int cbow;
std::string wordvector_file;
int64_t word_count_actual;
real starting_alpha;
std::array<real,(EXP_TABLE_SIZE + 1)> expTable;
clock_t start;
std::vector<real> syn0, syn1, syn1neg;
// Tables
std::array<int, table_size> table;
public:
Word2Vec (
std::string train_file, //Use text data from <file> to train the model
std::string output_file = "", //Use <file> to save the resulting word vectors / word clusters
unsigned int min_count = 5, //This will discard words that appear less than <int> times; default is 5
int debug_mode = 2, //Set the debug mode (default = 2 = more info during training)
int binary = 0, //Save the resulting vectors in binary moded; default is 0 (off)
std::string save_vocab_file = "", //The vocabulary will be saved to <file>
std::string read_vocab_file = "", //The vocabulary will be read from <file>, not constructed from the training data
unsigned int layer1_size = 100, //Set size of word vectors; default is 100
unsigned int window = 5, //Set max skip length between words; default is 5
real sample = 1e-3, //Set threshold for occurrence of words. Those that appear with higher frequency in the training data will be randomly down-sampled; default is 1e-3, useful range is (0, 1e-5)
int hs = 0, //Use Hierarchical Softmax; default is 0 (not used)
int negative = 5, //Number of negative examples; default is 5, common values are 3 - 10 (0 = not used)
unsigned int num_threads = 12, //Use <int> threads (default 12)
int iter = 5, //Run more training iterations (default 5)
real alpha = 0.05, //Set the starting learning rate; default is 0.025 for skip-gram and 0.05 for CBOW
unsigned int classes = 0,//Output word classes rather than word vectors; default number of classes is 0 (vectors are written)
int cbow = 0, //Use the continuous bag of words model; default is 1 (use 0 for skip-gram model)
std::string wordvector_file = "" //Read the trained word vector file
):
WordEmbed (train_file, output_file, min_count, debug_mode, binary,save_vocab_file,read_vocab_file),
layer1_size (layer1_size),
window (window),
sample (sample),
hs (hs),
negative (negative),
num_threads (num_threads),
iter (iter),
alpha (alpha),
classes (classes),
cbow (cbow),
wordvector_file (wordvector_file)
{
min_reduce = 1,
vocab_size = 0;
train_words = 0;
word_count_actual=0;
file_size = 0;
ready_to_train = false;
if( CheckReady() ) ready_to_train = true;
};
void TrainModel ();
void CreateBinaryTree ();
void InitUnigramTable ();
void InitNet ();
void TrainModelThread (int tid);
};
//vocab cn word codelen point code
// Create binary Huffman tree using the word counts
// Frequent words will have short unique binary codes
void Word2Vec::CreateBinaryTree() {
// Words are not sorted at the beginning
int64_t a, b, i, min1i, min2i, pos1, pos2;
int64_t point[MAX_CODE_LENGTH];
char code[MAX_CODE_LENGTH];
std::vector<int64_t> count;
std::vector<int64_t> binary;
std::vector<int64_t> parent_node;
count.reserve(vocab_size * 2 + 1);
binary.reserve(vocab_size * 2 + 1);
parent_node.reserve(vocab_size * 2 +1);
for(a = 0; a < vocab_size; a++) count[a] = vocab[a].cn; // count word frequency
for(a = vocab_size; a < 2 * vocab_size; a++) count[a] = 1e15; // should be larger than any number in the vocabulary count
pos1 = vocab_size - 1;
pos2 = vocab_size; //
// following algorithm constructs the Huffman tree by adding one node at a time
for(a = 0; a < vocab_size - 1; a++) {
// First, find two smallest nodes 'min1, min2'
if(pos1 >= 0) {
if(count[pos1] < count[pos2]) {
min1i = pos1;
pos1--;
} else {
min1i = pos2;
pos2++;
}
} else {
min1i = pos2;
pos2++;
}
if(pos1 >= 0) {
if(count[pos1] < count[pos2]) {
min2i = pos1;
pos1--;
} else {
min2i = pos2;
pos2++;
}
} else {
min2i = pos2;
pos2++;
}
count[vocab_size + a] = count[min1i] + count[min2i]; // Creating parent node with summed frequency
parent_node[min1i] = vocab_size + a;
parent_node[min2i] = vocab_size + a; // Note that having a common parent node
binary[min2i] = 1; // min2i will point to root node at the final state
}
// Now assign binary code to each vocabulary word
for(a = 0; a < vocab_size; a++) {
b = a;
i = 0;
while(1) {
code[i] = binary[b];
point[i] = b;
i++;
b = parent_node[b];
if(b == vocab_size * 2 - 2) break;
}
vocab[a].codelen = i;
vocab[a].point[0] = vocab_size - 2;
for(b = 0; b < i; b++) {
vocab[a].code[i - b - 1] = code[b];
vocab[a].point[i - b] = point[b] - vocab_size;
}
}
}
// Begin of Learning Net
void Word2Vec::InitUnigramTable() {
unsigned int i;
double train_words_pow = 0;
double d1, power = 0.75;
int64_t sum = 0;
for (unsigned int a = 0; a < vocab_size; a++) train_words_pow += pow(vocab[a].cn, power);
for (unsigned int a = 0; a < vocab_size; a++) sum += vocab[a].cn;
std::cout << sum << std::endl;
i = 0;
d1 = pow(vocab[i].cn, power) / train_words_pow;
for (unsigned int a = 0; a < table_size; a++) {
table[a] = i;
if (a / (double)table_size > d1) {
i++;
d1 += pow(vocab[i].cn, power) / train_words_pow;
}
if (i >= vocab_size) i = vocab_size - 1;
}
}
void Word2Vec::InitNet() {
// The name EXP_TABLE is totally mis-guiding.
for (int i = 0; i < EXP_TABLE_SIZE; i++) {
expTable[i] = exp((i / (real)EXP_TABLE_SIZE * 2 - 1) * MAX_EXP);
expTable[i] = expTable[i] / (expTable[i] + 1);
}
syn0.reserve((int64_t)vocab_size * layer1_size);
if(hs) {
syn1.reserve((int64_t)vocab_size * layer1_size);
for(unsigned int a = 0; a < vocab_size; a++)
for(unsigned int b = 0; b < layer1_size; b++)
syn1[a * layer1_size + b] = 0;
}
if(negative > 0) {
syn1neg.reserve((int64_t)vocab_size * layer1_size);
for(unsigned int a = 0; a < vocab_size; a++)
for(unsigned int b = 0; b < layer1_size; b++)
syn1neg[a * layer1_size + b] = 0;
}
for(unsigned int a = 0; a < vocab_size; a++)
for(unsigned int b = 0; b < layer1_size; b++)
syn0[a * layer1_size + b] = (rand()/(double)RAND_MAX - 0.5) / layer1_size;
//CreateBinaryTree();
}
void Word2Vec::TrainModelThread(int tid){
int64_t a, b, d, word, last_word, sentence_length = 0, sentence_position = 0;
int64_t word_count = 0, last_word_count = 0, sen[MAX_SENTENCE_LENGTH + 1];
int64_t l1, l2, c, target, label, local_iter = iter;
uint64_t next_random;
real f, g;
clock_t now;
boost::mt19937 rand_engine_int; // rand engine
boost::uniform_int<> rand_int(0, table_size); // set range.
boost::variate_generator<boost::mt19937, boost::uniform_int<>> rand_gen_int(rand_engine_int, rand_int);
boost::mt19937 rand_engine_double; // rand engine
boost::uniform_real<> rand_double(0.0, 1.0);
boost::variate_generator<boost::mt19937, boost::uniform_real<>> rand_gen_double(rand_engine_double, rand_double);
std::vector<real> neu1;
std::vector<real> neu1e;
neu1.reserve(layer1_size);
neu1e.reserve(layer1_size);
std::ifstream inFile(train_file, std::ifstream::in | std::ifstream::binary);
inFile.seekg(file_size / (int64_t)num_threads * (int64_t)tid);
while(1) {
if(word_count - last_word_count > 10000) {
word_count_actual += word_count - last_word_count;
last_word_count = word_count;
if((debug_mode > 1)) {
now = clock();
printf("%cAlpha: %f Progress: %.2f%% Words/thread/sec: %.2fk ", 13, alpha,
word_count_actual / (real)(iter * train_words + 1) * 100,
word_count_actual / ((real)(now - start + 1) / (real)CLOCKS_PER_SEC * 1000));
fflush(stdout);
}
alpha = starting_alpha * (1 - word_count_actual / (real)(iter * train_words + 1));
if(alpha < starting_alpha * 0.0001) alpha = starting_alpha * 0.0001;
}
if(sentence_length == 0) {
while(1) {
word = ReadWordIndex(inFile);
if(inFile.eof()) break;
if(word == -1) continue;
word_count++;
if(word == 0) break;
// The subsampling randomly discards frequent words while keeping the ranking same
if(sample > 0) {
real ran = (sqrt(vocab[word].cn / (sample * train_words)) + 1) * (sample * train_words) / vocab[word].cn;
if(ran < rand_gen_double()) continue;
}
sen[sentence_length] = word;
sentence_length++;
if(sentence_length >= MAX_SENTENCE_LENGTH) break;
}
sentence_position = 0;
}
if(inFile.eof() || (word_count > train_words / num_threads )) {
word_count_actual += word_count - last_word_count;
local_iter--;
if(local_iter == 0) break;
word_count = 0;
last_word_count = 0;
sentence_length = 0;
if(inFile.eof()) {
inFile.clear();
inFile.seekg(file_size / (int64_t)num_threads * (int64_t)tid);
}
else {
inFile.seekg(file_size / (int64_t)num_threads * (int64_t)tid);
}
continue;
}
word = sen[sentence_position];
if(word == -1) continue;
// Network Initialization
for(c = 0; c < layer1_size; c++) neu1[c] = 0;
for(c = 0; c < layer1_size; c++) neu1e[c] = 0;
b = rand_gen_int() % window;
// Skip-gram
{
for(a = b; a < window * 2 + 1 - b; a++) if(a != window) {
c = sentence_position - window + a;
if(c < 0) continue;
if(c >= sentence_length) continue;
last_word = sen[c];
if(last_word == -1) continue;
l1 = last_word * layer1_size;
// Hierarchical Softmax
if(hs) for(d = 0; d < vocab[word].codelen; d++) {
f = 0;
l2 = vocab[word].point[d] * layer1_size;
// Propagate hidden -> output
for(c = 0; c < layer1_size; c++) f += syn0[c + l1] * syn1[c + l2];
if(f <= -MAX_EXP) continue;
else if(f >= MAX_EXP) continue;
else f = expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))];
// g is the gradient multiplied by the learning rate
g = (1 - vocab[word].code[d] - f) * alpha;
// Backpropagate errors output -> hidden
for(c = 0; c < layer1_size; c++) neu1e[c] += g * syn1[c + l2];
// Learn weights hidden -> output
for(c = 0; c < layer1_size; c++) syn1[c + l2] += g * syn0[c +l1];
}
// Negative Sampling
if(negative > 0) for (d = 0; d < negative + 1 ; d++) {
if(d == 0) {
target = word;
label = 1;
} else {
next_random = rand_gen_int();
target = table[next_random % table_size];
if(target == 0) target = next_random % (vocab_size - 1) + 1;
if(target == word) continue;
label = 0;
}
l2 = target * layer1_size;
f = 0;
for(c = 0; c < layer1_size; c++) f += syn0[c + l1] * syn1neg[c + l2];
if(f > MAX_EXP) g = (label - 1) * alpha;
else if(f < -MAX_EXP) g = (label - 0) * alpha;
else g = (label - expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))]) * alpha;
for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1neg[c + l2];
for (c = 0; c < layer1_size; c++) syn1neg[c + l2] += g * syn0[c + l1];
}
// Learn weights input -> hidden
for(c = 0; c < layer1_size; c++) syn0[c + l1] += neu1e[c];
}
}
sentence_position++;
if(sentence_position >= sentence_length) {
sentence_length = 0;
continue;
}
}
inFile.close();
}
void Word2Vec::TrainModel() {
std::ofstream outFile;
std::vector<std::thread> th;
starting_alpha = alpha;
std::cout << "Starting training using file " << train_file << std::endl;
if(read_vocab_file != "") ReadVocab();
else ExtractVocabFromTrainFile();
if(save_vocab_file != "") SaveVocab();
if(output_file[0] == 0) return;
// Initialization
InitNet();
if(negative > 0)
InitUnigramTable();
start = clock(); // start to measure time
for(int i = 0; i < num_threads; i++) {
th.push_back(std::thread(&Word2Vec::TrainModelThread, this, i));
}
for(auto &t : th) {
t.join();
}
//TrainModelThread(); // For the single thread
outFile.open(output_file, std::ofstream::out | std::ofstream::binary);
if(classes == 0) {
outFile << vocab_size << " " << layer1_size << std::endl;
for(unsigned int a = 0; a < vocab_size; a++) {
outFile << vocab[a].word << " ";
if(binary) for(unsigned int b = 0; b < layer1_size; b++) outFile << syn0[a * layer1_size + b] << " ";
else for(unsigned int b = 0; b < layer1_size; b++) outFile << syn0[a * layer1_size + b] << " ";
outFile << std::endl;
}
} else {
// Run K-means on the word vectors
unsigned int clcn = classes, iter = 10, closeid;
real closev, x;
std::vector<int> centcn, cl;
std::vector<real> cent;
centcn.reserve(classes);
cl.reserve(vocab_size);
cent.reserve(classes * layer1_size);
for (unsigned int a = 0; a < vocab_size; a++) cl[a] = a % clcn;
for (unsigned int a = 0; a < iter; a++) {
for (unsigned int b = 0; b < clcn * layer1_size; b++) cent[b] = 0;
for (unsigned int b = 0; b < clcn; b++) centcn[b] = 1;
for (unsigned int c = 0; c < vocab_size; c++) {
for (unsigned int d = 0; d < layer1_size; d++) cent[layer1_size * cl[c] + d] += syn0[c * layer1_size + d];
centcn[cl[c]]++;
}
for (unsigned int b = 0; b < clcn; b++) {
closev = 0;
for (unsigned int c = 0; c < layer1_size; c++) {
cent[layer1_size * b + c] /= centcn[b];
closev += cent[layer1_size * b + c] * cent[layer1_size * b + c];
}
closev = sqrt(closev);
for (unsigned int c = 0; c < layer1_size; c++) cent[layer1_size * b + c] /= closev;
}
for (unsigned int c = 0; c < vocab_size; c++) {
closev = -10;
closeid = 0;
for (unsigned int d = 0; d < clcn; d++) {
x = 0;
for (unsigned int b = 0; b < layer1_size; b++) x += cent[layer1_size * d + b] * syn0[c * layer1_size + b];
if (x > closev) {
closev = x;
closeid = d;
}
}
cl[c] = closeid;
}
}
// Save the K-means classes
for (unsigned int a = 0; a < vocab_size; a++) outFile << vocab[a].word << " " << cl[a] << std::endl;
}
outFile.close();
}
// End of Learning Net
// main function arguments
void printHelp() {
std::cout << "c++ word2vector implementation \n\n";
std::cout << "Options:\n";
std::cout << "Parameters for training:\n";
std::cout << "\t-train <file>\n";
std::cout << "\t\tUse text data from <file> to train the model\n";
std::cout << "\t-output <file>\n";
std::cout << "\t\tUse <file> to save the resulting word vectors / word clusters\n";
std::cout << "\t-size <int>\n";
std::cout << "\t\tSet size of word vectors; default is 100\n";
std::cout << "\t-window <int>\n";
std::cout << "\t\tSet max skip length between words; default is 5\n";
std::cout << "\t-sample <float>\n";
std::cout << "\t\tSet threshold for occurrence of words. Those that appear with higher frequency in the training data\n";
std::cout << "\t\twill be randomly down-sampled; default is 1e-3, useful range is (0, 1e-5)\n";
std::cout << "\t-hs <int>\n";
std::cout << "\t\tUse Hierarchical Softmax; default is 0 (not used)\n";
std::cout << "\t-negative <int>\n";
std::cout << "\t\tNumber of negative examples; default is 5, common values are 3 - 10 (0 = not used)\n";
std::cout << "\t-threads <int>\n";
std::cout << "\t\tUse <int> threads (default 12)\n";
std::cout << "\t-iter <int>\n";
std::cout << "\t\tRun more training iterations (default 5)\n";
std::cout << "\t-min-count <int>\n";
std::cout << "\t\tThis will discard words that appear less than <int> times; default is 5\n";
std::cout << "\t-alpha <float>\n";
std::cout << "\t\tSet the starting learning rate; default is 0.025 for skip-gram and 0.05 for CBOW\n";
std::cout << "\t-classes <int>\n";
std::cout << "\t\tOutput word classes rather than word vectors; default number of classes is 0 (vectors are written)\n";
std::cout << "\t-debug <int>\n";
std::cout << "\t\tSet the debug mode (default = 2 = more info during training)\n";
std::cout << "\t-binary <int>\n";
std::cout << "\t\tSave the resulting vectors in binary moded; default is 0 (off)\n";
std::cout << "\t-save-vocab <file>\n";
std::cout << "\t\tThe vocabulary will be saved to <file>\n";
std::cout << "\t-read-vocab <file>\n";
std::cout << "\t\tThe vocabulary will be read from <file>, not constructed from the training data\n";
std::cout << "\t-cbow <int>\n";
std::cout << "\t\tUse the continuous bag of words model; default is 1 (use 0 for skip-gram model)\n";
std::cout << "\t-wordvector <file>\n";
std::cout << "\t\tRead the trained word vector file\n";
std::cout << "\nExamples:\n";
std::cout << "./word2vec -train data.txt -output vec.txt -size 200 -window 5 -sample 1e-4 -negative 5 -hs 0 -binary 0 -cbow 1 -iter 3\n\n";
}
int argpos(const char *str, int argc, char **argv) {
std::string s_str(str);
std::vector<std::string> s_argv(argv,argv+argc);
int i=0;
while (i<argc) {
if(s_str == s_argv[i]) break;
i++;
}
if(i == argc) i=0;
return i;
}
Word2Vec *arg_to_w2v(int argc, char **argv) {
int i;
int layer1_size = 100;
std::string train_file ="", save_vocab_file = "", read_vocab_file = "";
int debug_mode =2, binary = 0, cbow = 0;
real alpha = 0.05;
std::string output_file = "";
int window = 5;
real sample = 1e-3;
int hs = 0, negative = 5, num_threads = 12;
int64_t iter = 5;
int min_count = 5;
int64_t classes = 0;
std::string wordvector_file = "";
if ((i = argpos("-size", argc, argv)) > 0) layer1_size = atoi(argv[i + 1]);
if ((i = argpos("-train", argc, argv)) > 0) train_file = argv[i + 1];
if ((i = argpos("-save-vocab", argc, argv)) > 0) save_vocab_file = argv[i + 1];
if ((i = argpos("-read-vocab", argc, argv)) > 0) read_vocab_file = argv[i + 1];
if ((i = argpos("-debug", argc, argv)) > 0) debug_mode = atoi(argv[i + 1]);
if ((i = argpos("-binary", argc, argv)) > 0) binary = atoi(argv[i + 1]);
if ((i = argpos("-cbow", argc, argv)) > 0) cbow = atoi(argv[i + 1]);
if (cbow) alpha = 0.05; else alpha = 0.025;
if ((i = argpos("-alpha", argc, argv)) > 0) alpha = atof(argv[i + 1]);
if ((i = argpos("-output", argc, argv)) > 0) output_file = argv[i + 1];
if ((i = argpos("-window", argc, argv)) > 0) window = atoi(argv[i + 1]);
if ((i = argpos("-sample", argc, argv)) > 0) sample = atof(argv[i + 1]);
if ((i = argpos("-hs", argc, argv)) > 0) hs = atoi(argv[i + 1]);
if ((i = argpos("-negative", argc, argv)) > 0) negative = atoi(argv[i + 1]);
if ((i = argpos("-threads", argc, argv)) > 0) num_threads = atoi(argv[i + 1]);
if ((i = argpos("-iter", argc, argv)) > 0) iter = atoi(argv[i + 1]);
if ((i = argpos("-min-count", argc, argv)) > 0) min_count = atoi(argv[i + 1]);
if ((i = argpos("-classes", argc, argv)) > 0) classes = atoi(argv[i + 1]);
if ((i = argpos("-wordvector", argc, argv)) > 0) wordvector_file = argv[i + 1];
Word2Vec *w2v = new Word2Vec (
train_file,
output_file,
min_count,
debug_mode,
binary,
save_vocab_file,
read_vocab_file,
layer1_size,
window,
sample,
hs,
negative,
num_threads,
iter,
alpha,
classes,
cbow,
wordvector_file );
return w2v;
}
int main(int argc, char **argv) {
std::srand(11596521);
Word2Vec *w2v;
if(argc < 2) { printHelp(); return 1; }
else {
w2v = arg_to_w2v(argc, argv);
}
w2v->TrainModel();
return 0;
}
| 22,987 | 8,053 |
#include "mainwindow2.h"
#include "ui_mainwindow2.h"
#include "potiondisplay.h"
#include "carddisplay.h"
MainWindow2::MainWindow2(QWidget *parent) :
QWidget(parent),
ui(new Ui::MainWindow2)
{
ui->setupUi(this);
// CustomButton* button = new CustomButton(this, "Runs");
// this->ui->layout_options->addWidget(button);
// this->ui->layout_options->addWidget(new CustomButton(this, "statistics"));
// this->ui->layout_options->addWidget(new CustomButton(this, "help"));
// this->ui->layout_options->addWidget(new CustomButton(this, "options"));
// this->ui->layout_options->addStretch(1);
// this->ui->layout_potions->addWidget(new PotionDisplay());
// this->ui->layout_cards->addWidget(new CardDisplay());
//this->ui->gridLayout->addItem(new QSpacerItem(Qt::Horizontal));
}
MainWindow2::~MainWindow2()
{
delete ui;
}
| 867 | 300 |
#include <algorithm>
#include <array>
#include <vector>
#include "third_party/gflags/include/gflags.h"
#include "third_party/glog/include/logging.h"
using std::array;
class MyQueue {
stack<int> in;
stack<int> out;
void reload() {
while (in.size()) {
out.push(in.top());
in.pop();
}
}
public:
/** Initialize your data structure here. */
MyQueue() {}
/** Push element x to the back of queue. */
void push(int x) { in.push(x); }
/** Removes the element from in front of queue and returns that element. */
int pop() {
if (out.size()) {
int result = out.top();
out.pop();
return result;
}
reload();
int result = out.top();
out.pop();
return result;
}
/** Get the front element. */
int peek() {
if (out.size()) return out.top();
reload();
return out.top();
}
/** Returns whether the queue is empty. */
bool empty() { return in.size() == 0 && out.size() == 0; }
};
int main(int argc, char* argv[]) {
google::InitGoogleLogging(argv[0]);
gflags::ParseCommandLineFlags(&argc, &argv, false);
return 0;
}
| 1,115 | 393 |
/**
* Copyright (c) 2011 10gen Inc.
* Copyright (C) 2013 Tokutek Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "mongo/pch.h"
#include <vector>
#include "mongo/db/auth/action_set.h"
#include "mongo/db/auth/action_type.h"
#include "mongo/db/auth/privilege.h"
#include "mongo/db/commands.h"
#include "mongo/db/command_cursors.h"
#include "mongo/db/namespacestring.h"
#include "mongo/db/interrupt_status_mongod.h"
#include "mongo/db/pipeline/accumulator.h"
#include "mongo/db/pipeline/document.h"
#include "mongo/db/pipeline/document_source.h"
#include "mongo/db/pipeline/expression_context.h"
#include "mongo/db/pipeline/expression.h"
#include "mongo/db/pipeline/pipeline_d.h"
#include "mongo/db/pipeline/pipeline.h"
#include "mongo/db/ops/query.h"
namespace mongo {
extern const int MaxBytesToReturnToClientAtOnce;
class PipelineCursor : public Cursor {
public:
PipelineCursor(intrusive_ptr<Pipeline> pipeline)
: _pipeline(pipeline)
{}
// "core" cursor protocol
virtual bool ok() { return !iterator()->eof(); }
virtual bool advance() { return iterator()->advance(); }
virtual BSONObj current() {
BSONObjBuilder builder;
iterator()->getCurrent().toBson(&builder);
return builder.obj();
}
virtual bool shouldDestroyOnNSDeletion() { return false; }
virtual bool getsetdup(const BSONObj &pk) { return false; } // we don't generate dups
virtual bool isMultiKey() const { return false; }
virtual bool modifiedKeys() const { return false; }
virtual string toString() const { return "Aggregate_Cursor"; }
// These probably won't be needed once aggregation supports it's own explain.
virtual long long nscanned() const { return 0; }
virtual void explainDetails( BSONObjBuilder& b ) const { return; }
private:
const DocumentSource* iterator() const { return _pipeline->output(); }
DocumentSource* iterator() { return _pipeline->output(); }
intrusive_ptr<Pipeline> _pipeline;
};
class PipelineCommand :
public Command {
public:
// virtuals from Command
virtual ~PipelineCommand();
virtual bool run(const string &db, BSONObj &cmdObj, int options,
string &errmsg, BSONObjBuilder &result, bool fromRepl);
virtual LockType locktype() const;
// can't know if you're going to do a write op yet, you just shouldn't do aggregate on a SyncClusterConnection
virtual bool requiresSync() const { return true; }
virtual bool needsTxn() const { return false; }
virtual int txnFlags() const { return noTxnFlags(); }
virtual bool canRunInMultiStmtTxn() const { return true; }
virtual OpSettings getOpSettings() const { return OpSettings().setBulkFetch(true); }
virtual bool slaveOk() const;
// aggregate is like a query, we don't need to hold this lock
virtual bool requiresShardedOperationScope() const { return false; }
virtual void help(stringstream &help) const;
virtual void addRequiredPrivileges(const std::string& dbname,
const BSONObj& cmdObj,
std::vector<Privilege>* out);
PipelineCommand();
private:
/*
For the case of explain, we don't want to hold any lock at all,
because it generates warnings about recursive locks. However,
the getting the explain information for the underlying cursor uses
the direct client cursor, and that gets a lock. Therefore, we need
to take steps to avoid holding a lock while we use that. On the
other hand, we need to have a READ lock for normal explain execution.
Therefore, the lock is managed manually, and not through the virtual
locktype() above.
In order to achieve this, locktype() returns NONE, but the lock that
would be managed for reading (for executing the pipeline in the
regular way), will be managed manually here. This code came from
dbcommands.cpp, where objects are constructed to hold the lock
and automatically release it on destruction. The use of this
pattern requires extra functions to hold the lock scope and from
within which to execute the other steps of the explain.
The arguments for these are all the same, and come from run(), but
are passed in so that new blocks can be created to hold the
automatic locking objects.
*/
/*
Execute the pipeline for the explain. This is common to both the
locked and unlocked code path. However, the results are different.
For an explain, with no lock, it really outputs the pipeline
chain rather than fetching the data.
*/
bool executeSplitPipeline(
BSONObjBuilder& result, string& errmsg, const string& ns, const string& db,
intrusive_ptr<Pipeline>& pPipeline,
intrusive_ptr<ExpressionContext>& pCtx);
};
// self-registering singleton static instance
static PipelineCommand pipelineCommand;
PipelineCommand::PipelineCommand():
Command(Pipeline::commandName) {
}
Command::LockType PipelineCommand::locktype() const {
// Locks are managed manually, in particular by DocumentSourceCursor.
return OPLOCK;
}
bool PipelineCommand::slaveOk() const {
return true;
}
void PipelineCommand::help(stringstream &help) const {
help << "{ pipeline : [ { <data-pipe-op>: {...}}, ... ] }";
}
void PipelineCommand::addRequiredPrivileges(const std::string& dbname,
const BSONObj& cmdObj,
std::vector<Privilege>* out) {
ActionSet actions;
actions.addAction(ActionType::find);
out->push_back(Privilege(parseNs(dbname, cmdObj), actions));
}
PipelineCommand::~PipelineCommand() {
}
bool PipelineCommand::executeSplitPipeline(
BSONObjBuilder& result, string& errmsg,
const string& ns, const string& db,
intrusive_ptr<Pipeline>& pPipeline,
intrusive_ptr<ExpressionContext>& pCtx) {
/* setup as if we're in the router */
pCtx->setInRouter(true);
/*
Here, we'll split the pipeline in the same way we would for sharding,
for testing purposes.
Run the shard pipeline first, then feed the results into the remains
of the existing pipeline.
Start by splitting the pipeline.
*/
intrusive_ptr<Pipeline> pShardSplit(
pPipeline->splitForSharded());
/*
Write the split pipeline as we would in order to transmit it to
the shard servers.
*/
BSONObjBuilder shardBuilder;
pShardSplit->toBson(&shardBuilder);
BSONObj shardBson(shardBuilder.done());
DEV (log() << "\n---- shardBson\n" <<
shardBson.jsonString(Strict, 1) << "\n----\n").flush();
/* for debugging purposes, show what the pipeline now looks like */
DEV {
BSONObjBuilder pipelineBuilder;
pPipeline->toBson(&pipelineBuilder);
BSONObj pipelineBson(pipelineBuilder.done());
(log() << "\n---- pipelineBson\n" <<
pipelineBson.jsonString(Strict, 1) << "\n----\n").flush();
}
/* on the shard servers, create the local pipeline */
intrusive_ptr<ExpressionContext> pShardCtx(
ExpressionContext::create(&InterruptStatusMongod::status));
intrusive_ptr<Pipeline> pShardPipeline(
Pipeline::parseCommand(errmsg, shardBson, pShardCtx));
if (!pShardPipeline.get()) {
return false;
}
PipelineD::prepareCursorSource(pShardPipeline, nsToDatabase(ns), pCtx);
/* run the shard pipeline */
BSONObjBuilder shardResultBuilder;
string shardErrmsg;
pShardPipeline->stitch();
pShardPipeline->run(shardResultBuilder);
BSONObj shardResult(shardResultBuilder.done());
/* pick out the shard result, and prepare to read it */
intrusive_ptr<DocumentSourceBsonArray> pShardSource;
BSONObjIterator shardIter(shardResult);
while(shardIter.more()) {
BSONElement shardElement(shardIter.next());
const char *pFieldName = shardElement.fieldName();
if ((strcmp(pFieldName, "result") == 0) ||
(strcmp(pFieldName, "serverPipeline") == 0)) {
pPipeline->addInitialSource(DocumentSourceBsonArray::create(&shardElement, pCtx));
pPipeline->stitch();
/*
Connect the output of the shard pipeline with the mongos
pipeline that will merge the results.
*/
pPipeline->run(result);
return true;
}
}
/* NOTREACHED */
verify(false);
return false;
}
bool PipelineCommand::run(const string &db, BSONObj &cmdObj,
int options, string &errmsg,
BSONObjBuilder &result, bool fromRepl) {
intrusive_ptr<ExpressionContext> pCtx(
ExpressionContext::create(&InterruptStatusMongod::status));
/* try to parse the command; if this fails, then we didn't run */
intrusive_ptr<Pipeline> pPipeline(
Pipeline::parseCommand(errmsg, cmdObj, pCtx));
if (!pPipeline.get())
return false;
string ns(parseNs(db, cmdObj));
if (pPipeline->getSplitMongodPipeline()) {
// This is only used in testing
return executeSplitPipeline(result, errmsg, ns, db, pPipeline, pCtx);
}
#if _DEBUG
// This is outside of the if block to keep the object alive until the pipeline is finished.
BSONObj parsed;
if (!pPipeline->isExplain() && !pCtx->getInShard()) {
// Make sure all operations round-trip through Pipeline::toBson()
// correctly by reparsing every command on DEBUG builds. This is
// important because sharded aggregations rely on this ability.
// Skipping when inShard because this has already been through the
// transformation (and this unsets pCtx->inShard).
BSONObjBuilder bb;
pPipeline->toBson(&bb);
parsed = bb.obj();
pPipeline = Pipeline::parseCommand(errmsg, parsed, pCtx);
verify(pPipeline);
}
#endif
// This does the mongod-specific stuff like creating a cursor
PipelineD::prepareCursorSource(pPipeline, nsToDatabase(ns), pCtx);
pPipeline->stitch();
if (isCursorCommand(cmdObj)) {
CursorId id;
{
// Set up cursor
LOCK_REASON(lockReason, "aggregate: creating aggregation cursor");
Client::ReadContext ctx(ns, lockReason);
shared_ptr<Cursor> cursor(new PipelineCursor(pPipeline));
// cc will be owned by cursor manager
ClientCursor* cc = new ClientCursor(0, cursor, ns, cmdObj.getOwned());
id = cc->cursorid();
}
handleCursorCommand(id, cmdObj, result);
}
else {
pPipeline->run(result);
}
return true;
}
} // namespace mongo
| 12,260 | 3,348 |
//------------------------------------------------------------------------------
/// \file Epoll_main.cpp
/// \author Ernest Yeung
/// \email ernestyalumni@gmail.com
/// \brief epoll as RAII main driver file.
/// \ref http://man7.org/linux/man-pages/man2/epoll_create.2.html
/// \details Using RAII for epoll instance.
/// \copyright If you find this code useful, feel free to donate directly and easily at
/// this direct PayPal link:
///
/// https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=ernestsaveschristmas%2bpaypal%40gmail%2ecom&lc=US&item_name=ernestyalumni¤cy_code=USD&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted
///
/// which won't go through a 3rd. party such as indiegogo, kickstarter, patreon.
/// Otherwise, I receive emails and messages on how all my (free) material on
/// physics, math, and engineering have helped students with their studies, and
/// I know what it's like to not have money as a student, but love physics (or
/// math, sciences, etc.), so I am committed to keeping all my material
/// open-source and free, whether or not sufficiently crowdfunded, under the
/// open-source MIT license: feel free to copy, edit, paste, make your own
/// versions, share, use as you wish.
/// Peace out, never give up! -EY
//------------------------------------------------------------------------------
/// COMPILATION TIPS:
/// g++ -std=c++14 Epoll_main.cpp -o Epoll_main
//------------------------------------------------------------------------------
#include "Epoll.h"
#include "../Utilities/casts.h" // get_underlying
#include <iostream>
#include <sys/epoll.h>
using IO::ControlOperations;
using IO::Epoll;
using IO::EpollEvent;
using IO::EpollFlags;
using IO::EventTypes;
using Utilities::get_underlying_value;
template <EpollFlags EpollFlag = EpollFlags::default_value>
class TestableEpoll : public Epoll<EpollFlag>
{
public:
// Inherit default ctor
using Epoll<EpollFlag>::Epoll;
using Epoll<EpollFlag>::add_fd;
using Epoll<EpollFlag>::fd;
};
int main()
{
// EpollFlags
{
std::cout << "\n EpollFlags \n";
std::cout << " EpollFlags::default_value : " <<
static_cast<int>(EpollFlags::default_value) << '\n'; // 0
std::cout << " EpollFlags::close_on_execute : " <<
static_cast<int>(EpollFlags::close_on_execute) << '\n'; // 524288
}
// ControlOperations
{
std::cout << "\n ControlOperations \n";
std::cout << " ControlOperations::add : " <<
static_cast<int>(ControlOperations::add) << '\n'; // 1
std::cout << " ControlOperations::modify : " <<
static_cast<int>(ControlOperations::modify) << '\n'; // 3
std::cout << " ControlOperations::remove : " <<
static_cast<int>(ControlOperations::remove) << '\n'; // 2
}
// EventTypes
{
std::cout << "\n EventTypes \n";
std::cout << " EventTypes::default_value : " <<
static_cast<int>(EventTypes::default_value) << '\n'; // 0
std::cout << " EventTypes::read : " <<
static_cast<int>(EventTypes::read) << '\n'; // 1
std::cout << " EventTypes::write : " <<
static_cast<int>(EventTypes::write) << '\n'; // 4
std::cout << " EventTypes::stream_or_half_hangup : " <<
static_cast<int>(EventTypes::stream_or_half_hangup) << '\n'; // 8192
std::cout << " EventTypes::exceptional : " <<
static_cast<int>(EventTypes::exceptional) << '\n'; // 2
std::cout << " EventTypes::error : " <<
static_cast<int>(EventTypes::error) << '\n'; // 8
std::cout << " EventTypes::hangup : " <<
static_cast<int>(EventTypes::hangup) << '\n'; // 16
std::cout << " EventTypes::edge_triggered : " <<
static_cast<int>(EventTypes::edge_triggered) << '\n'; // -2147483648
std::cout << " EventTypes::one_shot : " <<
static_cast<int>(EventTypes::one_shot) << '\n'; // 1073741824
std::cout << " EventTypes::wakeup : " <<
static_cast<int>(EventTypes::wakeup) << '\n'; // 536870912
std::cout << " EventTypes::exclusive : " <<
static_cast<int>(EventTypes::exclusive) << '\n'; // 268435456
}
// EpollEventConstructs
{
std::cout << "\n EpollEventConstructs \n";
const EpollEvent epoll_event {
get_underlying_value<EventTypes>(EventTypes::default_value),
5};
std::cout << " epoll_event : " << epoll_event << '\n';
// const EpollEvent<get_underlying_value<EventTypes>(EventTypes::read)>
// WORKS
// static_cast<std::underlying_type_t<EventTypes>>(EventTypes::read)>
const EpollEvent epoll_event_1 {EventTypes::read, 5};
std::cout << " epoll_event_1 : " << epoll_event_1 << '\n';
const EpollEvent epoll_event_2 {
get_underlying_value<EventTypes>(EventTypes::read) ||
get_underlying_value<EventTypes>(EventTypes::edge_triggered),
5};
std::cout << " epoll_event_2 : " << epoll_event_2 << '\n';
}
std::cout << get_underlying_value<EventTypes>(EventTypes::read) << '\n';
std::cout << get_underlying_value<EventTypes>(EventTypes::edge_triggered) <<
'\n';
std::cout << (get_underlying_value<EventTypes>(EventTypes::read)
|| get_underlying_value<EventTypes>(EventTypes::edge_triggered)) << '\n';
std::cout << (get_underlying_value<EventTypes>(EventTypes::write)
|| get_underlying_value<EventTypes>(EventTypes::exclusive)) << '\n';
std::cout << " EPOLLIN : " << EPOLLIN << '\n';
std::cout << " EPOLLOUT : " << EPOLLOUT << '\n';
std::cout << " EPOLLET : " << EPOLLET << '\n';
std::cout << " EPOLLEXCLUSIVE : " << EPOLLEXCLUSIVE << '\n';
std::cout << (EPOLLIN || EPOLLET) << '\n';
std::cout << (EPOLLOUT || EPOLLEXCLUSIVE) << '\n';
// EpollDefaultConstructs
{
std::cout << " \n EpollDefaultConstructs \n";
const Epoll<> epoll;
const TestableEpoll<> test_epoll;
std::cout << " test_epoll.fd() : " << test_epoll.fd() << '\n';
}
// AddFdAddsFdIntoEpollSet
{
std::cout << "\n AddFdAddsFdIntoEpollSet \n";
}
}
| 5,936 | 2,096 |
//---------------------------------------------------------------------------//
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//
#include <algorithm>
#include <iostream>
#include <vector>
#include <mimalloc.h>
#include <boost/timer/timer.hpp>
#include <boost/compute/system.hpp>
#include <boost/compute/command_queue.hpp>
#include <boost/compute/algorithm/sort.hpp>
#include <boost/compute/container/vector.hpp>
#include "perf.hpp"
int main(int argc, char *argv[])
{
perf_parse_args(argc, argv);
std::cout << "size: " << PERF_N << std::endl;
// setup context and queue for the default device
boost::compute::device device = boost::compute::system::default_device();
boost::compute::context context(device);
boost::compute::command_queue queue(context, device);
std::cout << "device: " << device.name() << std::endl;
// create vector of random numbers on the host
std::vector<int, mi_stl_allocator<int>> random_vector(PERF_N);
std::generate(random_vector.begin(), random_vector.end(), rand);
// create input vector for gpu
std::vector<int, mi_stl_allocator<int>> gpu_vector = random_vector;
// sort vector on gpu
boost::timer::cpu_timer t;
boost::compute::sort(
gpu_vector.begin(), gpu_vector.end(), queue);
queue.finish();
std::cout << "time: " << t.elapsed().wall / 1e6 << " ms" << std::endl;
// create input vector for host
std::vector<int, mi_stl_allocator<int>> host_vector = random_vector;
// sort vector on host
t.start();
std::sort(host_vector.begin(), host_vector.end());
std::cout << "host time: " << t.elapsed().wall / 1e6 << " ms" << std::endl;
// ensure that both sorted vectors are equal
if (!std::equal(gpu_vector.begin(), gpu_vector.end(), host_vector.begin()))
{
std::cerr << "ERROR: sorted vectors not the same" << std::endl;
return -1;
}
return 0;
}
| 2,232 | 723 |
#pragma once
#include "events/Event.hpp"
namespace Birdy3d::events {
class InputScrollEvent : public Event {
public:
const double xoffset;
const double yoffset;
InputScrollEvent(double xoffset, double yoffset)
: xoffset(xoffset)
, yoffset(yoffset) { }
};
class InputClickEvent : public Event {
public:
const int button;
const int action;
const int mods;
InputClickEvent(int button, int action, int mods)
: button(button)
, action(action)
, mods(mods) { }
};
class InputKeyEvent : public Event {
public:
const int key;
const int scancode;
const int action;
const int mods;
InputKeyEvent(int key, int scancode, int action, int mods)
: key(key)
, scancode(scancode)
, action(action)
, mods(mods) { }
bool check_options(std::any options) override {
int key_option = std::any_cast<int>(options);
return key_option == key && action == 1; // GLFW_PRESS
}
};
class InputCharEvent : public Event {
public:
const unsigned int codepoint;
InputCharEvent(unsigned int codepoint)
: codepoint(codepoint) { }
};
}
| 1,330 | 379 |
/*
* Copyright (C) 2018 Daniel Scharrer
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the author(s) be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#include "crypto/arc4.hpp"
#include <algorithm>
#include "util/endian.hpp"
namespace crypto {
void arc4::init(const char * key, size_t length) {
a = b = 0;
for(size_t i = 0; i < sizeof(state); i++){
state[i] = boost::uint8_t(i);
}
size_t j = 0;
for(size_t i = 0; i < sizeof(state); i++) {
j = (j + state[i] + boost::uint8_t(key[i % length])) % sizeof(state);
std::swap(state[i], state[j]);
}
}
void arc4::update() {
a = (a + 1) % sizeof(state);
b = (b + state[a]) % sizeof(state);
std::swap(state[a], state[b]);
}
void arc4::discard(size_t length) {
for(size_t i = 0; i < length; i++) {
update();
}
}
void arc4::crypt(const char * in, char * out, size_t length) {
for(size_t i = 0; i < length; i++) {
update();
out[i] = char(state[size_t(state[a] + state[b]) % sizeof(state)] ^ boost::uint8_t(in[i]));
}
}
} // namespace crypto
| 1,796 | 648 |
//------------------------------------------------------------------------------
// BadWordFilter.cpp
// (C) 2016 n.lee
//------------------------------------------------------------------------------
#include "BadWordFilter.h"
#include "CharCode.h"
wchar_t *
wreplace(wchar_t *buffer, const wchar_t *dirty, const wchar_t ch) {
int len = wcslen(dirty);
wchar_t *p = buffer;
int i;
while (nullptr != (p = wcsstr(p, dirty))) {
for (i = 0; i < len; ++i) {
*p++ = L'*';
}
}
return buffer;
}
//------------------------------------------------------------------------------
/**
*/
CBadWordFilter::CBadWordFilter() {
}
//------------------------------------------------------------------------------
/**
*/
CBadWordFilter::~CBadWordFilter() {
}
//------------------------------------------------------------------------------
/**
*/
void
CBadWordFilter::LoadFromFile(const char *sFile) {
char chLine[1024];
//
FILE *fp = fopen(sFile, "r");
if (fp) {
while (nullptr != fgets(chLine, sizeof(chLine), fp)) {
// remove tail '\r' and '\n'
int nIndex = strlen(chLine);
while (--nIndex > 0) {
if ('\r' != chLine[nIndex] && '\n' != chLine[nIndex]) {
break;
}
chLine[nIndex] = '\0';
}
//
if (nIndex > 0) {
AddWord(chLine);
}
}
fclose(fp);
}
}
//------------------------------------------------------------------------------
/**
*/
void
CBadWordFilter::OnFilter(char *sInput) {
int nLen = CCharCode::Gb2312ToUnicode(_wbuffer, 1024, sInput, strlen(sInput));
bool bFiltered = false;
int i;
std::vector<std::wstring > *v;
tWcharKeyMap::iterator itBadWord;
for (i = 0; i < nLen; ++i) {
//
if (L'*' == *(_wbuffer + i) || L' ' == *(_wbuffer + i) || L'\t' == *(_wbuffer + i) || L'\0' == *(_wbuffer + i))
continue;
//
itBadWord = _mapBadKey.find(*(_wbuffer + i));
if (itBadWord == _mapBadKey.end())
continue;
//
v = &(itBadWord->second);
for (auto& it : (*v)) {
wreplace(_wbuffer, it.c_str(), L'*');
bFiltered = true;
}
}
//
CCharCode::UnicodeToGB2312(sInput, strlen(sInput), _wbuffer, nLen);
}
//------------------------------------------------------------------------------
/**
*/
void
CBadWordFilter::AddWord(const char *sWord) {
wchar_t chBuffer[1024] = { 0 };
int nLen = CCharCode::Gb2312ToUnicode(chBuffer, 1024, sWord, strlen(sWord));
_badWordList.push_back(chBuffer);
int i;
std::vector<std::wstring> *v;
wchar_t *p = chBuffer;
for (i = 0; i < nLen; ++i) {
if (L'*' == *(p + i) || L' ' == *(p + i) || L'\t' == *(p + i) || L'\0' == *(p + i))
continue;
v = &_mapBadKey[*(p + i)];
std::vector<std::wstring>::iterator it = v->begin(), itEnd = v->end();
while (it != itEnd) {
if ((*it) == chBuffer) {
v->erase(it);
break;
}
++it;
}
v->push_back(chBuffer);
}
}
/* -- EOF -- */ | 2,962 | 1,249 |
#ifndef __NOVEMBERIZING_IO__REACTOR__HH__
#define __NOVEMBERIZING_IO__REACTOR__HH__
#include <sys/epoll.h>
#include <unistd.h>
#include <novemberizing/util/log.hh>
#include <novemberizing/ds.hh>
#include <novemberizing/ds/cyclable.hh>
#include <novemberizing/ds/concurrent.set.hh>
#include <novemberizing/io.hh>
#include <novemberizing/io/descriptor.hh>
namespace novemberizing { namespace io {
using namespace util;
using namespace ds;
class Reactor : public Cyclable
{
public: static const int DefaultDescriptorSize = 1024;
public: static const int DefaultTimeout = 10;
private: ConcurrentSet<Descriptor *> __descriptors;
private: int __descriptor;
private: int __max;
private: int __reserved;
private: int __timeout;
private: struct epoll_event * __events;
public: virtual int add(Descriptor * descriptor);
public: virtual int del(Descriptor * descriptor);
public: virtual int mod(Descriptor * descriptor);
public: virtual void onecycle(void);
private: virtual void initialize(void);
public: Reactor(void);
public: virtual ~Reactor(void);
};
} }
#endif // __NOVEMBERIZING_IO__REACTOR__HH__
| 1,159 | 386 |
#include <iostream>
#include <QString>
#include <QVector>
#include <QDebug>
#include <QCryptographicHash>
#include <QCoreApplication>
#include "md5revert_helpers.h"
#include "0/0/0/000.h"
#include "0/0/1/001.h"
#include "0/0/2/002.h"
#include "0/0/3/003.h"
#include "0/0/4/004.h"
#include "0/0/5/005.h"
#include "0/0/6/006.h"
#include "0/0/7/007.h"
#include "0/0/8/008.h"
#include "0/0/9/009.h"
#include "0/1/0/010.h"
#include "0/1/1/011.h"
#include "0/1/2/012.h"
#include "0/1/3/013.h"
#include "0/1/4/014.h"
#include "0/1/5/015.h"
#include "0/1/6/016.h"
#include "0/1/7/017.h"
#include "0/1/8/018.h"
#include "0/1/9/019.h"
#include "0/2/0/020.h"
#include "0/2/1/021.h"
#include "0/2/2/022.h"
#include "0/2/3/023.h"
#include "0/2/4/024.h"
#include "0/2/5/025.h"
#include "0/2/6/026.h"
#include "0/2/7/027.h"
#include "0/2/8/028.h"
#include "0/2/9/029.h"
#include "0/3/0/030.h"
#include "0/3/1/031.h"
#include "0/3/2/032.h"
#include "0/3/3/033.h"
#include "0/3/4/034.h"
#include "0/3/5/035.h"
#include "0/3/6/036.h"
#include "0/3/7/037.h"
#include "0/3/8/038.h"
#include "0/3/9/039.h"
#include "0/4/0/040.h"
#include "0/4/1/041.h"
#include "0/4/2/042.h"
#include "0/4/3/043.h"
#include "0/4/4/044.h"
#include "0/4/5/045.h"
#include "0/4/6/046.h"
#include "0/4/7/047.h"
#include "0/4/8/048.h"
#include "0/4/9/049.h"
#include "0/5/0/050.h"
#include "0/5/1/051.h"
#include "0/5/2/052.h"
#include "0/5/3/053.h"
#include "0/5/4/054.h"
#include "0/5/5/055.h"
#include "0/5/6/056.h"
#include "0/5/7/057.h"
#include "0/5/8/058.h"
#include "0/5/9/059.h"
#include "0/6/0/060.h"
#include "0/6/1/061.h"
#include "0/6/2/062.h"
#include "0/6/3/063.h"
#include "0/6/4/064.h"
#include "0/6/5/065.h"
#include "0/6/6/066.h"
#include "0/6/7/067.h"
#include "0/6/8/068.h"
#include "0/6/9/069.h"
#include "0/7/0/070.h"
#include "0/7/1/071.h"
#include "0/7/2/072.h"
#include "0/7/3/073.h"
#include "0/7/4/074.h"
#include "0/7/5/075.h"
#include "0/7/6/076.h"
#include "0/7/7/077.h"
#include "0/7/8/078.h"
#include "0/7/9/079.h"
#include "0/8/0/080.h"
#include "0/8/1/081.h"
#include "0/8/2/082.h"
#include "0/8/3/083.h"
#include "0/8/4/084.h"
#include "0/8/5/085.h"
#include "0/8/6/086.h"
#include "0/8/7/087.h"
#include "0/8/8/088.h"
#include "0/8/9/089.h"
#include "0/9/0/090.h"
#include "0/9/1/091.h"
#include "0/9/2/092.h"
#include "0/9/3/093.h"
#include "0/9/4/094.h"
#include "0/9/5/095.h"
#include "0/9/6/096.h"
#include "0/9/7/097.h"
#include "0/9/8/098.h"
#include "0/9/9/099.h"
#include "1/0/0/100.h"
#include "1/0/1/101.h"
#include "1/0/2/102.h"
#include "1/0/3/103.h"
#include "1/0/4/104.h"
#include "1/0/5/105.h"
#include "1/0/6/106.h"
#include "1/0/7/107.h"
#include "1/0/8/108.h"
#include "1/0/9/109.h"
#include "1/1/0/110.h"
#include "1/1/1/111.h"
#include "1/1/2/112.h"
#include "1/1/3/113.h"
#include "1/1/4/114.h"
#include "1/1/5/115.h"
#include "1/1/6/116.h"
#include "1/1/7/117.h"
#include "1/1/8/118.h"
#include "1/1/9/119.h"
#include "1/2/0/120.h"
#include "1/2/1/121.h"
#include "1/2/2/122.h"
#include "1/2/3/123.h"
#include "1/2/4/124.h"
#include "1/2/5/125.h"
#include "1/2/6/126.h"
#include "1/2/7/127.h"
#include "1/2/8/128.h"
#include "1/2/9/129.h"
#include "1/3/0/130.h"
#include "1/3/1/131.h"
#include "1/3/2/132.h"
#include "1/3/3/133.h"
#include "1/3/4/134.h"
#include "1/3/5/135.h"
#include "1/3/6/136.h"
#include "1/3/7/137.h"
#include "1/3/8/138.h"
#include "1/3/9/139.h"
#include "1/4/0/140.h"
#include "1/4/1/141.h"
#include "1/4/2/142.h"
#include "1/4/3/143.h"
#include "1/4/4/144.h"
#include "1/4/5/145.h"
#include "1/4/6/146.h"
#include "1/4/7/147.h"
#include "1/4/8/148.h"
#include "1/4/9/149.h"
#include "1/5/0/150.h"
#include "1/5/1/151.h"
#include "1/5/2/152.h"
#include "1/5/3/153.h"
#include "1/5/4/154.h"
#include "1/5/5/155.h"
#include "1/5/6/156.h"
#include "1/5/7/157.h"
#include "1/5/8/158.h"
#include "1/5/9/159.h"
#include "1/6/0/160.h"
#include "1/6/1/161.h"
#include "1/6/2/162.h"
#include "1/6/3/163.h"
#include "1/6/4/164.h"
#include "1/6/5/165.h"
#include "1/6/6/166.h"
#include "1/6/7/167.h"
#include "1/6/8/168.h"
#include "1/6/9/169.h"
#include "1/7/0/170.h"
#include "1/7/1/171.h"
#include "1/7/2/172.h"
#include "1/7/3/173.h"
#include "1/7/4/174.h"
#include "1/7/5/175.h"
#include "1/7/6/176.h"
#include "1/7/7/177.h"
#include "1/7/8/178.h"
#include "1/7/9/179.h"
#include "1/8/0/180.h"
#include "1/8/1/181.h"
#include "1/8/2/182.h"
#include "1/8/3/183.h"
#include "1/8/4/184.h"
#include "1/8/5/185.h"
#include "1/8/6/186.h"
#include "1/8/7/187.h"
#include "1/8/8/188.h"
#include "1/8/9/189.h"
#include "1/9/0/190.h"
#include "1/9/1/191.h"
#include "1/9/2/192.h"
#include "1/9/3/193.h"
#include "1/9/4/194.h"
#include "1/9/5/195.h"
#include "1/9/6/196.h"
#include "1/9/7/197.h"
#include "1/9/8/198.h"
#include "1/9/9/199.h"
#include "2/0/0/200.h"
#include "2/0/1/201.h"
#include "2/0/2/202.h"
#include "2/0/3/203.h"
#include "2/0/4/204.h"
#include "2/0/5/205.h"
#include "2/0/6/206.h"
#include "2/0/7/207.h"
#include "2/0/8/208.h"
#include "2/0/9/209.h"
#include "2/1/0/210.h"
#include "2/1/1/211.h"
#include "2/1/2/212.h"
#include "2/1/3/213.h"
#include "2/1/4/214.h"
#include "2/1/5/215.h"
#include "2/1/6/216.h"
#include "2/1/7/217.h"
#include "2/1/8/218.h"
#include "2/1/9/219.h"
#include "2/2/0/220.h"
#include "2/2/1/221.h"
#include "2/2/2/222.h"
#include "2/2/3/223.h"
#include "2/2/4/224.h"
#include "2/2/5/225.h"
#include "2/2/6/226.h"
#include "2/2/7/227.h"
#include "2/2/8/228.h"
#include "2/2/9/229.h"
#include "2/3/0/230.h"
#include "2/3/1/231.h"
#include "2/3/2/232.h"
#include "2/3/3/233.h"
#include "2/3/4/234.h"
#include "2/3/5/235.h"
#include "2/3/6/236.h"
#include "2/3/7/237.h"
#include "2/3/8/238.h"
#include "2/3/9/239.h"
#include "2/4/0/240.h"
#include "2/4/1/241.h"
#include "2/4/2/242.h"
#include "2/4/3/243.h"
#include "2/4/4/244.h"
#include "2/4/5/245.h"
#include "2/4/6/246.h"
#include "2/4/7/247.h"
#include "2/4/8/248.h"
#include "2/4/9/249.h"
#include "2/5/0/250.h"
#include "2/5/1/251.h"
#include "2/5/2/252.h"
#include "2/5/3/253.h"
#include "2/5/4/254.h"
#include "2/5/5/255.h"
#include "2/5/6/256.h"
#include "2/5/7/257.h"
#include "2/5/8/258.h"
#include "2/5/9/259.h"
#include "2/6/0/260.h"
#include "2/6/1/261.h"
#include "2/6/2/262.h"
#include "2/6/3/263.h"
#include "2/6/4/264.h"
#include "2/6/5/265.h"
#include "2/6/6/266.h"
#include "2/6/7/267.h"
#include "2/6/8/268.h"
#include "2/6/9/269.h"
#include "2/7/0/270.h"
#include "2/7/1/271.h"
#include "2/7/2/272.h"
#include "2/7/3/273.h"
#include "2/7/4/274.h"
#include "2/7/5/275.h"
#include "2/7/6/276.h"
#include "2/7/7/277.h"
#include "2/7/8/278.h"
#include "2/7/9/279.h"
#include "2/8/0/280.h"
#include "2/8/1/281.h"
#include "2/8/2/282.h"
#include "2/8/3/283.h"
#include "2/8/4/284.h"
#include "2/8/5/285.h"
#include "2/8/6/286.h"
#include "2/8/7/287.h"
#include "2/8/8/288.h"
#include "2/8/9/289.h"
#include "2/9/0/290.h"
#include "2/9/1/291.h"
#include "2/9/2/292.h"
#include "2/9/3/293.h"
#include "2/9/4/294.h"
#include "2/9/5/295.h"
#include "2/9/6/296.h"
#include "2/9/7/297.h"
#include "2/9/8/298.h"
#include "2/9/9/299.h"
#include "3/0/0/300.h"
#include "3/0/1/301.h"
#include "3/0/2/302.h"
#include "3/0/3/303.h"
#include "3/0/4/304.h"
#include "3/0/5/305.h"
#include "3/0/6/306.h"
#include "3/0/7/307.h"
#include "3/0/8/308.h"
#include "3/0/9/309.h"
#include "3/1/0/310.h"
#include "3/1/1/311.h"
#include "3/1/2/312.h"
#include "3/1/3/313.h"
#include "3/1/4/314.h"
#include "3/1/5/315.h"
#include "3/1/6/316.h"
#include "3/1/7/317.h"
#include "3/1/8/318.h"
#include "3/1/9/319.h"
#include "3/2/0/320.h"
#include "3/2/1/321.h"
#include "3/2/2/322.h"
#include "3/2/3/323.h"
#include "3/2/4/324.h"
#include "3/2/5/325.h"
#include "3/2/6/326.h"
#include "3/2/7/327.h"
#include "3/2/8/328.h"
#include "3/2/9/329.h"
#include "3/3/0/330.h"
#include "3/3/1/331.h"
#include "3/3/2/332.h"
#include "3/3/3/333.h"
#include "3/3/4/334.h"
#include "3/3/5/335.h"
#include "3/3/6/336.h"
#include "3/3/7/337.h"
#include "3/3/8/338.h"
#include "3/3/9/339.h"
#include "3/4/0/340.h"
#include "3/4/1/341.h"
#include "3/4/2/342.h"
#include "3/4/3/343.h"
#include "3/4/4/344.h"
#include "3/4/5/345.h"
#include "3/4/6/346.h"
#include "3/4/7/347.h"
#include "3/4/8/348.h"
#include "3/4/9/349.h"
#include "3/5/0/350.h"
#include "3/5/1/351.h"
#include "3/5/2/352.h"
#include "3/5/3/353.h"
#include "3/5/4/354.h"
#include "3/5/5/355.h"
#include "3/5/6/356.h"
#include "3/5/7/357.h"
#include "3/5/8/358.h"
#include "3/5/9/359.h"
#include "3/6/0/360.h"
#include "3/6/1/361.h"
#include "3/6/2/362.h"
#include "3/6/3/363.h"
#include "3/6/4/364.h"
#include "3/6/5/365.h"
#include "3/6/6/366.h"
#include "3/6/7/367.h"
#include "3/6/8/368.h"
#include "3/6/9/369.h"
#include "3/7/0/370.h"
#include "3/7/1/371.h"
#include "3/7/2/372.h"
#include "3/7/3/373.h"
#include "3/7/4/374.h"
#include "3/7/5/375.h"
#include "3/7/6/376.h"
#include "3/7/7/377.h"
#include "3/7/8/378.h"
#include "3/7/9/379.h"
#include "3/8/0/380.h"
#include "3/8/1/381.h"
#include "3/8/2/382.h"
#include "3/8/3/383.h"
#include "3/8/4/384.h"
#include "3/8/5/385.h"
#include "3/8/6/386.h"
#include "3/8/7/387.h"
#include "3/8/8/388.h"
#include "3/8/9/389.h"
#include "3/9/0/390.h"
#include "3/9/1/391.h"
#include "3/9/2/392.h"
#include "3/9/3/393.h"
#include "3/9/4/394.h"
#include "3/9/5/395.h"
#include "3/9/6/396.h"
#include "3/9/7/397.h"
#include "3/9/8/398.h"
#include "3/9/9/399.h"
#include "4/0/0/400.h"
#include "4/0/1/401.h"
#include "4/0/2/402.h"
#include "4/0/3/403.h"
#include "4/0/4/404.h"
#include "4/0/5/405.h"
#include "4/0/6/406.h"
#include "4/0/7/407.h"
#include "4/0/8/408.h"
#include "4/0/9/409.h"
#include "4/1/0/410.h"
#include "4/1/1/411.h"
#include "4/1/2/412.h"
#include "4/1/3/413.h"
#include "4/1/4/414.h"
#include "4/1/5/415.h"
#include "4/1/6/416.h"
#include "4/1/7/417.h"
#include "4/1/8/418.h"
#include "4/1/9/419.h"
#include "4/2/0/420.h"
#include "4/2/1/421.h"
#include "4/2/2/422.h"
#include "4/2/3/423.h"
#include "4/2/4/424.h"
#include "4/2/5/425.h"
#include "4/2/6/426.h"
#include "4/2/7/427.h"
#include "4/2/8/428.h"
#include "4/2/9/429.h"
#include "4/3/0/430.h"
#include "4/3/1/431.h"
#include "4/3/2/432.h"
#include "4/3/3/433.h"
#include "4/3/4/434.h"
#include "4/3/5/435.h"
#include "4/3/6/436.h"
#include "4/3/7/437.h"
#include "4/3/8/438.h"
#include "4/3/9/439.h"
void print_help(QVector<QString> &vParams) {
std::cout << "\n"
<< " Please usage: " << vParams[0].toStdString() << " [md5]\n"
<< "\n";
};
int main(int argc, char* argv[]){
QCoreApplication app(argc, argv);
QCoreApplication::setApplicationName("reversehash");
QVector<QString> vParams;
for(int i = 0; i < argc; i++){
vParams.push_back(QString(argv[i]));
}
if(vParams.size() < 2 || vParams.size() > 2){
print_help(vParams);
return -1;
}
QString hash = vParams[1];
if(hash.size() != 32){
qDebug().noquote().nospace() << "invalid md5";
print_help(vParams);
return -1;
};
QVector<bool> hash_bool;
convertHEXStringToVBool(hash, hash_bool, 128);
bool in0 = hash_bool[0];
bool in1 = hash_bool[1];
bool in2 = hash_bool[2];
bool in3 = hash_bool[3];
bool in4 = hash_bool[4];
bool in5 = hash_bool[5];
bool in6 = hash_bool[6];
bool in7 = hash_bool[7];
bool in8 = hash_bool[8];
bool in9 = hash_bool[9];
bool in10 = hash_bool[10];
bool in11 = hash_bool[11];
bool in12 = hash_bool[12];
bool in13 = hash_bool[13];
bool in14 = hash_bool[14];
bool in15 = hash_bool[15];
bool in16 = hash_bool[16];
bool in17 = hash_bool[17];
bool in18 = hash_bool[18];
bool in19 = hash_bool[19];
bool in20 = hash_bool[20];
bool in21 = hash_bool[21];
bool in22 = hash_bool[22];
bool in23 = hash_bool[23];
bool in24 = hash_bool[24];
bool in25 = hash_bool[25];
bool in26 = hash_bool[26];
bool in27 = hash_bool[27];
bool in28 = hash_bool[28];
bool in29 = hash_bool[29];
bool in30 = hash_bool[30];
bool in31 = hash_bool[31];
bool in32 = hash_bool[32];
bool in33 = hash_bool[33];
bool in34 = hash_bool[34];
bool in35 = hash_bool[35];
bool in36 = hash_bool[36];
bool in37 = hash_bool[37];
bool in38 = hash_bool[38];
bool in39 = hash_bool[39];
bool in40 = hash_bool[40];
bool in41 = hash_bool[41];
bool in42 = hash_bool[42];
bool in43 = hash_bool[43];
bool in44 = hash_bool[44];
bool in45 = hash_bool[45];
bool in46 = hash_bool[46];
bool in47 = hash_bool[47];
bool in48 = hash_bool[48];
bool in49 = hash_bool[49];
bool in50 = hash_bool[50];
bool in51 = hash_bool[51];
bool in52 = hash_bool[52];
bool in53 = hash_bool[53];
bool in54 = hash_bool[54];
bool in55 = hash_bool[55];
bool in56 = hash_bool[56];
bool in57 = hash_bool[57];
bool in58 = hash_bool[58];
bool in59 = hash_bool[59];
bool in60 = hash_bool[60];
bool in61 = hash_bool[61];
bool in62 = hash_bool[62];
bool in63 = hash_bool[63];
bool in64 = hash_bool[64];
bool in65 = hash_bool[65];
bool in66 = hash_bool[66];
bool in67 = hash_bool[67];
bool in68 = hash_bool[68];
bool in69 = hash_bool[69];
bool in70 = hash_bool[70];
bool in71 = hash_bool[71];
bool in72 = hash_bool[72];
bool in73 = hash_bool[73];
bool in74 = hash_bool[74];
bool in75 = hash_bool[75];
bool in76 = hash_bool[76];
bool in77 = hash_bool[77];
bool in78 = hash_bool[78];
bool in79 = hash_bool[79];
bool in80 = hash_bool[80];
bool in81 = hash_bool[81];
bool in82 = hash_bool[82];
bool in83 = hash_bool[83];
bool in84 = hash_bool[84];
bool in85 = hash_bool[85];
bool in86 = hash_bool[86];
bool in87 = hash_bool[87];
bool in88 = hash_bool[88];
bool in89 = hash_bool[89];
bool in90 = hash_bool[90];
bool in91 = hash_bool[91];
bool in92 = hash_bool[92];
bool in93 = hash_bool[93];
bool in94 = hash_bool[94];
bool in95 = hash_bool[95];
bool in96 = hash_bool[96];
bool in97 = hash_bool[97];
bool in98 = hash_bool[98];
bool in99 = hash_bool[99];
bool in100 = hash_bool[100];
bool in101 = hash_bool[101];
bool in102 = hash_bool[102];
bool in103 = hash_bool[103];
bool in104 = hash_bool[104];
bool in105 = hash_bool[105];
bool in106 = hash_bool[106];
bool in107 = hash_bool[107];
bool in108 = hash_bool[108];
bool in109 = hash_bool[109];
bool in110 = hash_bool[110];
bool in111 = hash_bool[111];
bool in112 = hash_bool[112];
bool in113 = hash_bool[113];
bool in114 = hash_bool[114];
bool in115 = hash_bool[115];
bool in116 = hash_bool[116];
bool in117 = hash_bool[117];
bool in118 = hash_bool[118];
bool in119 = hash_bool[119];
bool in120 = hash_bool[120];
bool in121 = hash_bool[121];
bool in122 = hash_bool[122];
bool in123 = hash_bool[123];
bool in124 = hash_bool[124];
bool in125 = hash_bool[125];
bool in126 = hash_bool[126];
bool in127 = hash_bool[127];
QVector<bool> result_bool;
for(int i = 0; i < 440; i++){
result_bool.push_back(false);
}
bool out000;
func000(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out000);
result_bool[0] = out000;
bool out001;
func001(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out001);
result_bool[1] = out001;
bool out002;
func002(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out002);
result_bool[2] = out002;
bool out003;
func003(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out003);
result_bool[3] = out003;
bool out004;
func004(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out004);
result_bool[4] = out004;
bool out005;
func005(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out005);
result_bool[5] = out005;
bool out006;
func006(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out006);
result_bool[6] = out006;
bool out007;
func007(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out007);
result_bool[7] = out007;
bool out008;
func008(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out008);
result_bool[8] = out008;
bool out009;
func009(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out009);
result_bool[9] = out009;
bool out010;
func010(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out010);
result_bool[10] = out010;
bool out011;
func011(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out011);
result_bool[11] = out011;
bool out012;
func012(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out012);
result_bool[12] = out012;
bool out013;
func013(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out013);
result_bool[13] = out013;
bool out014;
func014(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out014);
result_bool[14] = out014;
bool out015;
func015(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out015);
result_bool[15] = out015;
bool out016;
func016(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out016);
result_bool[16] = out016;
bool out017;
func017(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out017);
result_bool[17] = out017;
bool out018;
func018(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out018);
result_bool[18] = out018;
bool out019;
func019(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out019);
result_bool[19] = out019;
bool out020;
func020(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out020);
result_bool[20] = out020;
bool out021;
func021(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out021);
result_bool[21] = out021;
bool out022;
func022(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out022);
result_bool[22] = out022;
bool out023;
func023(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out023);
result_bool[23] = out023;
bool out024;
func024(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out024);
result_bool[24] = out024;
bool out025;
func025(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out025);
result_bool[25] = out025;
bool out026;
func026(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out026);
result_bool[26] = out026;
bool out027;
func027(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out027);
result_bool[27] = out027;
bool out028;
func028(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out028);
result_bool[28] = out028;
bool out029;
func029(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out029);
result_bool[29] = out029;
bool out030;
func030(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out030);
result_bool[30] = out030;
bool out031;
func031(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out031);
result_bool[31] = out031;
bool out032;
func032(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out032);
result_bool[32] = out032;
bool out033;
func033(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out033);
result_bool[33] = out033;
bool out034;
func034(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out034);
result_bool[34] = out034;
bool out035;
func035(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out035);
result_bool[35] = out035;
bool out036;
func036(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out036);
result_bool[36] = out036;
bool out037;
func037(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out037);
result_bool[37] = out037;
bool out038;
func038(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out038);
result_bool[38] = out038;
bool out039;
func039(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out039);
result_bool[39] = out039;
bool out040;
func040(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out040);
result_bool[40] = out040;
bool out041;
func041(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out041);
result_bool[41] = out041;
bool out042;
func042(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out042);
result_bool[42] = out042;
bool out043;
func043(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out043);
result_bool[43] = out043;
bool out044;
func044(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out044);
result_bool[44] = out044;
bool out045;
func045(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out045);
result_bool[45] = out045;
bool out046;
func046(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out046);
result_bool[46] = out046;
bool out047;
func047(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out047);
result_bool[47] = out047;
bool out048;
func048(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out048);
result_bool[48] = out048;
bool out049;
func049(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out049);
result_bool[49] = out049;
bool out050;
func050(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out050);
result_bool[50] = out050;
bool out051;
func051(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out051);
result_bool[51] = out051;
bool out052;
func052(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out052);
result_bool[52] = out052;
bool out053;
func053(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out053);
result_bool[53] = out053;
bool out054;
func054(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out054);
result_bool[54] = out054;
bool out055;
func055(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out055);
result_bool[55] = out055;
bool out056;
func056(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out056);
result_bool[56] = out056;
bool out057;
func057(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out057);
result_bool[57] = out057;
bool out058;
func058(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out058);
result_bool[58] = out058;
bool out059;
func059(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out059);
result_bool[59] = out059;
bool out060;
func060(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out060);
result_bool[60] = out060;
bool out061;
func061(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out061);
result_bool[61] = out061;
bool out062;
func062(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out062);
result_bool[62] = out062;
bool out063;
func063(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out063);
result_bool[63] = out063;
bool out064;
func064(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out064);
result_bool[64] = out064;
bool out065;
func065(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out065);
result_bool[65] = out065;
bool out066;
func066(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out066);
result_bool[66] = out066;
bool out067;
func067(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out067);
result_bool[67] = out067;
bool out068;
func068(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out068);
result_bool[68] = out068;
bool out069;
func069(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out069);
result_bool[69] = out069;
bool out070;
func070(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out070);
result_bool[70] = out070;
bool out071;
func071(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out071);
result_bool[71] = out071;
bool out072;
func072(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out072);
result_bool[72] = out072;
bool out073;
func073(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out073);
result_bool[73] = out073;
bool out074;
func074(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out074);
result_bool[74] = out074;
bool out075;
func075(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out075);
result_bool[75] = out075;
bool out076;
func076(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out076);
result_bool[76] = out076;
bool out077;
func077(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out077);
result_bool[77] = out077;
bool out078;
func078(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out078);
result_bool[78] = out078;
bool out079;
func079(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out079);
result_bool[79] = out079;
bool out080;
func080(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out080);
result_bool[80] = out080;
bool out081;
func081(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out081);
result_bool[81] = out081;
bool out082;
func082(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out082);
result_bool[82] = out082;
bool out083;
func083(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out083);
result_bool[83] = out083;
bool out084;
func084(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out084);
result_bool[84] = out084;
bool out085;
func085(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out085);
result_bool[85] = out085;
bool out086;
func086(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out086);
result_bool[86] = out086;
bool out087;
func087(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out087);
result_bool[87] = out087;
bool out088;
func088(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out088);
result_bool[88] = out088;
bool out089;
func089(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out089);
result_bool[89] = out089;
bool out090;
func090(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out090);
result_bool[90] = out090;
bool out091;
func091(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out091);
result_bool[91] = out091;
bool out092;
func092(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out092);
result_bool[92] = out092;
bool out093;
func093(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out093);
result_bool[93] = out093;
bool out094;
func094(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out094);
result_bool[94] = out094;
bool out095;
func095(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out095);
result_bool[95] = out095;
bool out096;
func096(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out096);
result_bool[96] = out096;
bool out097;
func097(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out097);
result_bool[97] = out097;
bool out098;
func098(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out098);
result_bool[98] = out098;
bool out099;
func099(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out099);
result_bool[99] = out099;
bool out100;
func100(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out100);
result_bool[100] = out100;
bool out101;
func101(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out101);
result_bool[101] = out101;
bool out102;
func102(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out102);
result_bool[102] = out102;
bool out103;
func103(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out103);
result_bool[103] = out103;
bool out104;
func104(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out104);
result_bool[104] = out104;
bool out105;
func105(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out105);
result_bool[105] = out105;
bool out106;
func106(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out106);
result_bool[106] = out106;
bool out107;
func107(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out107);
result_bool[107] = out107;
bool out108;
func108(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out108);
result_bool[108] = out108;
bool out109;
func109(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out109);
result_bool[109] = out109;
bool out110;
func110(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out110);
result_bool[110] = out110;
bool out111;
func111(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out111);
result_bool[111] = out111;
bool out112;
func112(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out112);
result_bool[112] = out112;
bool out113;
func113(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out113);
result_bool[113] = out113;
bool out114;
func114(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out114);
result_bool[114] = out114;
bool out115;
func115(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out115);
result_bool[115] = out115;
bool out116;
func116(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out116);
result_bool[116] = out116;
bool out117;
func117(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out117);
result_bool[117] = out117;
bool out118;
func118(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out118);
result_bool[118] = out118;
bool out119;
func119(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out119);
result_bool[119] = out119;
bool out120;
func120(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out120);
result_bool[120] = out120;
bool out121;
func121(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out121);
result_bool[121] = out121;
bool out122;
func122(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out122);
result_bool[122] = out122;
bool out123;
func123(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out123);
result_bool[123] = out123;
bool out124;
func124(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out124);
result_bool[124] = out124;
bool out125;
func125(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out125);
result_bool[125] = out125;
bool out126;
func126(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out126);
result_bool[126] = out126;
bool out127;
func127(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out127);
result_bool[127] = out127;
bool out128;
func128(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out128);
result_bool[128] = out128;
bool out129;
func129(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out129);
result_bool[129] = out129;
bool out130;
func130(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out130);
result_bool[130] = out130;
bool out131;
func131(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out131);
result_bool[131] = out131;
bool out132;
func132(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out132);
result_bool[132] = out132;
bool out133;
func133(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out133);
result_bool[133] = out133;
bool out134;
func134(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out134);
result_bool[134] = out134;
bool out135;
func135(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out135);
result_bool[135] = out135;
bool out136;
func136(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out136);
result_bool[136] = out136;
bool out137;
func137(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out137);
result_bool[137] = out137;
bool out138;
func138(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out138);
result_bool[138] = out138;
bool out139;
func139(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out139);
result_bool[139] = out139;
bool out140;
func140(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out140);
result_bool[140] = out140;
bool out141;
func141(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out141);
result_bool[141] = out141;
bool out142;
func142(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out142);
result_bool[142] = out142;
bool out143;
func143(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out143);
result_bool[143] = out143;
bool out144;
func144(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out144);
result_bool[144] = out144;
bool out145;
func145(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out145);
result_bool[145] = out145;
bool out146;
func146(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out146);
result_bool[146] = out146;
bool out147;
func147(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out147);
result_bool[147] = out147;
bool out148;
func148(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out148);
result_bool[148] = out148;
bool out149;
func149(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out149);
result_bool[149] = out149;
bool out150;
func150(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out150);
result_bool[150] = out150;
bool out151;
func151(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out151);
result_bool[151] = out151;
bool out152;
func152(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out152);
result_bool[152] = out152;
bool out153;
func153(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out153);
result_bool[153] = out153;
bool out154;
func154(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out154);
result_bool[154] = out154;
bool out155;
func155(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out155);
result_bool[155] = out155;
bool out156;
func156(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out156);
result_bool[156] = out156;
bool out157;
func157(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out157);
result_bool[157] = out157;
bool out158;
func158(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out158);
result_bool[158] = out158;
bool out159;
func159(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out159);
result_bool[159] = out159;
bool out160;
func160(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out160);
result_bool[160] = out160;
bool out161;
func161(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out161);
result_bool[161] = out161;
bool out162;
func162(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out162);
result_bool[162] = out162;
bool out163;
func163(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out163);
result_bool[163] = out163;
bool out164;
func164(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out164);
result_bool[164] = out164;
bool out165;
func165(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out165);
result_bool[165] = out165;
bool out166;
func166(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out166);
result_bool[166] = out166;
bool out167;
func167(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out167);
result_bool[167] = out167;
bool out168;
func168(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out168);
result_bool[168] = out168;
bool out169;
func169(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out169);
result_bool[169] = out169;
bool out170;
func170(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out170);
result_bool[170] = out170;
bool out171;
func171(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out171);
result_bool[171] = out171;
bool out172;
func172(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out172);
result_bool[172] = out172;
bool out173;
func173(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out173);
result_bool[173] = out173;
bool out174;
func174(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out174);
result_bool[174] = out174;
bool out175;
func175(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out175);
result_bool[175] = out175;
bool out176;
func176(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out176);
result_bool[176] = out176;
bool out177;
func177(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out177);
result_bool[177] = out177;
bool out178;
func178(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out178);
result_bool[178] = out178;
bool out179;
func179(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out179);
result_bool[179] = out179;
bool out180;
func180(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out180);
result_bool[180] = out180;
bool out181;
func181(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out181);
result_bool[181] = out181;
bool out182;
func182(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out182);
result_bool[182] = out182;
bool out183;
func183(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out183);
result_bool[183] = out183;
bool out184;
func184(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out184);
result_bool[184] = out184;
bool out185;
func185(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out185);
result_bool[185] = out185;
bool out186;
func186(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out186);
result_bool[186] = out186;
bool out187;
func187(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out187);
result_bool[187] = out187;
bool out188;
func188(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out188);
result_bool[188] = out188;
bool out189;
func189(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out189);
result_bool[189] = out189;
bool out190;
func190(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out190);
result_bool[190] = out190;
bool out191;
func191(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out191);
result_bool[191] = out191;
bool out192;
func192(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out192);
result_bool[192] = out192;
bool out193;
func193(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out193);
result_bool[193] = out193;
bool out194;
func194(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out194);
result_bool[194] = out194;
bool out195;
func195(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out195);
result_bool[195] = out195;
bool out196;
func196(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out196);
result_bool[196] = out196;
bool out197;
func197(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out197);
result_bool[197] = out197;
bool out198;
func198(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out198);
result_bool[198] = out198;
bool out199;
func199(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out199);
result_bool[199] = out199;
bool out200;
func200(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out200);
result_bool[200] = out200;
bool out201;
func201(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out201);
result_bool[201] = out201;
bool out202;
func202(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out202);
result_bool[202] = out202;
bool out203;
func203(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out203);
result_bool[203] = out203;
bool out204;
func204(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out204);
result_bool[204] = out204;
bool out205;
func205(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out205);
result_bool[205] = out205;
bool out206;
func206(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out206);
result_bool[206] = out206;
bool out207;
func207(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out207);
result_bool[207] = out207;
bool out208;
func208(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out208);
result_bool[208] = out208;
bool out209;
func209(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out209);
result_bool[209] = out209;
bool out210;
func210(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out210);
result_bool[210] = out210;
bool out211;
func211(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out211);
result_bool[211] = out211;
bool out212;
func212(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out212);
result_bool[212] = out212;
bool out213;
func213(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out213);
result_bool[213] = out213;
bool out214;
func214(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out214);
result_bool[214] = out214;
bool out215;
func215(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out215);
result_bool[215] = out215;
bool out216;
func216(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out216);
result_bool[216] = out216;
bool out217;
func217(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out217);
result_bool[217] = out217;
bool out218;
func218(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out218);
result_bool[218] = out218;
bool out219;
func219(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out219);
result_bool[219] = out219;
bool out220;
func220(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out220);
result_bool[220] = out220;
bool out221;
func221(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out221);
result_bool[221] = out221;
bool out222;
func222(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out222);
result_bool[222] = out222;
bool out223;
func223(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out223);
result_bool[223] = out223;
bool out224;
func224(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out224);
result_bool[224] = out224;
bool out225;
func225(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out225);
result_bool[225] = out225;
bool out226;
func226(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out226);
result_bool[226] = out226;
bool out227;
func227(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out227);
result_bool[227] = out227;
bool out228;
func228(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out228);
result_bool[228] = out228;
bool out229;
func229(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out229);
result_bool[229] = out229;
bool out230;
func230(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out230);
result_bool[230] = out230;
bool out231;
func231(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out231);
result_bool[231] = out231;
bool out232;
func232(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out232);
result_bool[232] = out232;
bool out233;
func233(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out233);
result_bool[233] = out233;
bool out234;
func234(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out234);
result_bool[234] = out234;
bool out235;
func235(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out235);
result_bool[235] = out235;
bool out236;
func236(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out236);
result_bool[236] = out236;
bool out237;
func237(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out237);
result_bool[237] = out237;
bool out238;
func238(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out238);
result_bool[238] = out238;
bool out239;
func239(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out239);
result_bool[239] = out239;
bool out240;
func240(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out240);
result_bool[240] = out240;
bool out241;
func241(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out241);
result_bool[241] = out241;
bool out242;
func242(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out242);
result_bool[242] = out242;
bool out243;
func243(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out243);
result_bool[243] = out243;
bool out244;
func244(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out244);
result_bool[244] = out244;
bool out245;
func245(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out245);
result_bool[245] = out245;
bool out246;
func246(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out246);
result_bool[246] = out246;
bool out247;
func247(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out247);
result_bool[247] = out247;
bool out248;
func248(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out248);
result_bool[248] = out248;
bool out249;
func249(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out249);
result_bool[249] = out249;
bool out250;
func250(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out250);
result_bool[250] = out250;
bool out251;
func251(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out251);
result_bool[251] = out251;
bool out252;
func252(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out252);
result_bool[252] = out252;
bool out253;
func253(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out253);
result_bool[253] = out253;
bool out254;
func254(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out254);
result_bool[254] = out254;
bool out255;
func255(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out255);
result_bool[255] = out255;
bool out256;
func256(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out256);
result_bool[256] = out256;
bool out257;
func257(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out257);
result_bool[257] = out257;
bool out258;
func258(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out258);
result_bool[258] = out258;
bool out259;
func259(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out259);
result_bool[259] = out259;
bool out260;
func260(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out260);
result_bool[260] = out260;
bool out261;
func261(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out261);
result_bool[261] = out261;
bool out262;
func262(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out262);
result_bool[262] = out262;
bool out263;
func263(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out263);
result_bool[263] = out263;
bool out264;
func264(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out264);
result_bool[264] = out264;
bool out265;
func265(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out265);
result_bool[265] = out265;
bool out266;
func266(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out266);
result_bool[266] = out266;
bool out267;
func267(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out267);
result_bool[267] = out267;
bool out268;
func268(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out268);
result_bool[268] = out268;
bool out269;
func269(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out269);
result_bool[269] = out269;
bool out270;
func270(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out270);
result_bool[270] = out270;
bool out271;
func271(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out271);
result_bool[271] = out271;
bool out272;
func272(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out272);
result_bool[272] = out272;
bool out273;
func273(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out273);
result_bool[273] = out273;
bool out274;
func274(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out274);
result_bool[274] = out274;
bool out275;
func275(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out275);
result_bool[275] = out275;
bool out276;
func276(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out276);
result_bool[276] = out276;
bool out277;
func277(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out277);
result_bool[277] = out277;
bool out278;
func278(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out278);
result_bool[278] = out278;
bool out279;
func279(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out279);
result_bool[279] = out279;
bool out280;
func280(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out280);
result_bool[280] = out280;
bool out281;
func281(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out281);
result_bool[281] = out281;
bool out282;
func282(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out282);
result_bool[282] = out282;
bool out283;
func283(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out283);
result_bool[283] = out283;
bool out284;
func284(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out284);
result_bool[284] = out284;
bool out285;
func285(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out285);
result_bool[285] = out285;
bool out286;
func286(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out286);
result_bool[286] = out286;
bool out287;
func287(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out287);
result_bool[287] = out287;
bool out288;
func288(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out288);
result_bool[288] = out288;
bool out289;
func289(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out289);
result_bool[289] = out289;
bool out290;
func290(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out290);
result_bool[290] = out290;
bool out291;
func291(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out291);
result_bool[291] = out291;
bool out292;
func292(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out292);
result_bool[292] = out292;
bool out293;
func293(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out293);
result_bool[293] = out293;
bool out294;
func294(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out294);
result_bool[294] = out294;
bool out295;
func295(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out295);
result_bool[295] = out295;
bool out296;
func296(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out296);
result_bool[296] = out296;
bool out297;
func297(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out297);
result_bool[297] = out297;
bool out298;
func298(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out298);
result_bool[298] = out298;
bool out299;
func299(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out299);
result_bool[299] = out299;
bool out300;
func300(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out300);
result_bool[300] = out300;
bool out301;
func301(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out301);
result_bool[301] = out301;
bool out302;
func302(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out302);
result_bool[302] = out302;
bool out303;
func303(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out303);
result_bool[303] = out303;
bool out304;
func304(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out304);
result_bool[304] = out304;
bool out305;
func305(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out305);
result_bool[305] = out305;
bool out306;
func306(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out306);
result_bool[306] = out306;
bool out307;
func307(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out307);
result_bool[307] = out307;
bool out308;
func308(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out308);
result_bool[308] = out308;
bool out309;
func309(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out309);
result_bool[309] = out309;
bool out310;
func310(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out310);
result_bool[310] = out310;
bool out311;
func311(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out311);
result_bool[311] = out311;
bool out312;
func312(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out312);
result_bool[312] = out312;
bool out313;
func313(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out313);
result_bool[313] = out313;
bool out314;
func314(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out314);
result_bool[314] = out314;
bool out315;
func315(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out315);
result_bool[315] = out315;
bool out316;
func316(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out316);
result_bool[316] = out316;
bool out317;
func317(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out317);
result_bool[317] = out317;
bool out318;
func318(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out318);
result_bool[318] = out318;
bool out319;
func319(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out319);
result_bool[319] = out319;
bool out320;
func320(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out320);
result_bool[320] = out320;
bool out321;
func321(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out321);
result_bool[321] = out321;
bool out322;
func322(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out322);
result_bool[322] = out322;
bool out323;
func323(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out323);
result_bool[323] = out323;
bool out324;
func324(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out324);
result_bool[324] = out324;
bool out325;
func325(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out325);
result_bool[325] = out325;
bool out326;
func326(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out326);
result_bool[326] = out326;
bool out327;
func327(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out327);
result_bool[327] = out327;
bool out328;
func328(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out328);
result_bool[328] = out328;
bool out329;
func329(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out329);
result_bool[329] = out329;
bool out330;
func330(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out330);
result_bool[330] = out330;
bool out331;
func331(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out331);
result_bool[331] = out331;
bool out332;
func332(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out332);
result_bool[332] = out332;
bool out333;
func333(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out333);
result_bool[333] = out333;
bool out334;
func334(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out334);
result_bool[334] = out334;
bool out335;
func335(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out335);
result_bool[335] = out335;
bool out336;
func336(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out336);
result_bool[336] = out336;
bool out337;
func337(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out337);
result_bool[337] = out337;
bool out338;
func338(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out338);
result_bool[338] = out338;
bool out339;
func339(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out339);
result_bool[339] = out339;
bool out340;
func340(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out340);
result_bool[340] = out340;
bool out341;
func341(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out341);
result_bool[341] = out341;
bool out342;
func342(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out342);
result_bool[342] = out342;
bool out343;
func343(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out343);
result_bool[343] = out343;
bool out344;
func344(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out344);
result_bool[344] = out344;
bool out345;
func345(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out345);
result_bool[345] = out345;
bool out346;
func346(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out346);
result_bool[346] = out346;
bool out347;
func347(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out347);
result_bool[347] = out347;
bool out348;
func348(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out348);
result_bool[348] = out348;
bool out349;
func349(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out349);
result_bool[349] = out349;
bool out350;
func350(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out350);
result_bool[350] = out350;
bool out351;
func351(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out351);
result_bool[351] = out351;
bool out352;
func352(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out352);
result_bool[352] = out352;
bool out353;
func353(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out353);
result_bool[353] = out353;
bool out354;
func354(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out354);
result_bool[354] = out354;
bool out355;
func355(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out355);
result_bool[355] = out355;
bool out356;
func356(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out356);
result_bool[356] = out356;
bool out357;
func357(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out357);
result_bool[357] = out357;
bool out358;
func358(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out358);
result_bool[358] = out358;
bool out359;
func359(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out359);
result_bool[359] = out359;
bool out360;
func360(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out360);
result_bool[360] = out360;
bool out361;
func361(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out361);
result_bool[361] = out361;
bool out362;
func362(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out362);
result_bool[362] = out362;
bool out363;
func363(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out363);
result_bool[363] = out363;
bool out364;
func364(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out364);
result_bool[364] = out364;
bool out365;
func365(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out365);
result_bool[365] = out365;
bool out366;
func366(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out366);
result_bool[366] = out366;
bool out367;
func367(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out367);
result_bool[367] = out367;
bool out368;
func368(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out368);
result_bool[368] = out368;
bool out369;
func369(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out369);
result_bool[369] = out369;
bool out370;
func370(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out370);
result_bool[370] = out370;
bool out371;
func371(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out371);
result_bool[371] = out371;
bool out372;
func372(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out372);
result_bool[372] = out372;
bool out373;
func373(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out373);
result_bool[373] = out373;
bool out374;
func374(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out374);
result_bool[374] = out374;
bool out375;
func375(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out375);
result_bool[375] = out375;
bool out376;
func376(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out376);
result_bool[376] = out376;
bool out377;
func377(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out377);
result_bool[377] = out377;
bool out378;
func378(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out378);
result_bool[378] = out378;
bool out379;
func379(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out379);
result_bool[379] = out379;
bool out380;
func380(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out380);
result_bool[380] = out380;
bool out381;
func381(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out381);
result_bool[381] = out381;
bool out382;
func382(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out382);
result_bool[382] = out382;
bool out383;
func383(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out383);
result_bool[383] = out383;
bool out384;
func384(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out384);
result_bool[384] = out384;
bool out385;
func385(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out385);
result_bool[385] = out385;
bool out386;
func386(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out386);
result_bool[386] = out386;
bool out387;
func387(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out387);
result_bool[387] = out387;
bool out388;
func388(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out388);
result_bool[388] = out388;
bool out389;
func389(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out389);
result_bool[389] = out389;
bool out390;
func390(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out390);
result_bool[390] = out390;
bool out391;
func391(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out391);
result_bool[391] = out391;
bool out392;
func392(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out392);
result_bool[392] = out392;
bool out393;
func393(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out393);
result_bool[393] = out393;
bool out394;
func394(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out394);
result_bool[394] = out394;
bool out395;
func395(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out395);
result_bool[395] = out395;
bool out396;
func396(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out396);
result_bool[396] = out396;
bool out397;
func397(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out397);
result_bool[397] = out397;
bool out398;
func398(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out398);
result_bool[398] = out398;
bool out399;
func399(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out399);
result_bool[399] = out399;
bool out400;
func400(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out400);
result_bool[400] = out400;
bool out401;
func401(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out401);
result_bool[401] = out401;
bool out402;
func402(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out402);
result_bool[402] = out402;
bool out403;
func403(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out403);
result_bool[403] = out403;
bool out404;
func404(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out404);
result_bool[404] = out404;
bool out405;
func405(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out405);
result_bool[405] = out405;
bool out406;
func406(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out406);
result_bool[406] = out406;
bool out407;
func407(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out407);
result_bool[407] = out407;
bool out408;
func408(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out408);
result_bool[408] = out408;
bool out409;
func409(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out409);
result_bool[409] = out409;
bool out410;
func410(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out410);
result_bool[410] = out410;
bool out411;
func411(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out411);
result_bool[411] = out411;
bool out412;
func412(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out412);
result_bool[412] = out412;
bool out413;
func413(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out413);
result_bool[413] = out413;
bool out414;
func414(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out414);
result_bool[414] = out414;
bool out415;
func415(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out415);
result_bool[415] = out415;
bool out416;
func416(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out416);
result_bool[416] = out416;
bool out417;
func417(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out417);
result_bool[417] = out417;
bool out418;
func418(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out418);
result_bool[418] = out418;
bool out419;
func419(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out419);
result_bool[419] = out419;
bool out420;
func420(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out420);
result_bool[420] = out420;
bool out421;
func421(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out421);
result_bool[421] = out421;
bool out422;
func422(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out422);
result_bool[422] = out422;
bool out423;
func423(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out423);
result_bool[423] = out423;
bool out424;
func424(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out424);
result_bool[424] = out424;
bool out425;
func425(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out425);
result_bool[425] = out425;
bool out426;
func426(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out426);
result_bool[426] = out426;
bool out427;
func427(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out427);
result_bool[427] = out427;
bool out428;
func428(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out428);
result_bool[428] = out428;
bool out429;
func429(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out429);
result_bool[429] = out429;
bool out430;
func430(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out430);
result_bool[430] = out430;
bool out431;
func431(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out431);
result_bool[431] = out431;
bool out432;
func432(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out432);
result_bool[432] = out432;
bool out433;
func433(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out433);
result_bool[433] = out433;
bool out434;
func434(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out434);
result_bool[434] = out434;
bool out435;
func435(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out435);
result_bool[435] = out435;
bool out436;
func436(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out436);
result_bool[436] = out436;
bool out437;
func437(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out437);
result_bool[437] = out437;
bool out438;
func438(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out438);
result_bool[438] = out438;
bool out439;
func439(in0, in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, in17, in18, in19, in20, in21, in22, in23, in24, in25, in26, in27, in28, in29, in30, in31, in32, in33, in34, in35, in36, in37, in38, in39, in40, in41, in42, in43, in44, in45, in46, in47, in48, in49, in50, in51, in52, in53, in54, in55, in56, in57, in58, in59, in60, in61, in62, in63, in64, in65, in66, in67, in68, in69, in70, in71, in72, in73, in74, in75, in76, in77, in78, in79, in80, in81, in82, in83, in84, in85, in86, in87, in88, in89, in90, in91, in92, in93, in94, in95, in96, in97, in98, in99, in100, in101, in102, in103, in104, in105, in106, in107, in108, in109, in110, in111, in112, in113, in114, in115, in116, in117, in118, in119, in120, in121, in122, in123, in124, in125, in126, in127, out439);
result_bool[439] = out439;
qDebug().noquote().nospace() << "Original hash: " << hash;
QString result = convertVBoolHEXString(result_bool);
QByteArray out_array = QByteArray::fromHex(result.toLatin1());
QString hex_from_out = QString(QCryptographicHash::hash(out_array, QCryptographicHash::Md5).toHex());
qDebug().noquote().nospace() << "md5(revertedstring): " << hex_from_out;
qDebug().noquote().nospace() << "Reverted (HEX): " << result;
qDebug().noquote().nospace() << "Reverted string: " << QString(out_array);
return 0;
}
| 387,371 | 258,402 |
/*
* This file is part of QBDI.
*
* Copyright 2017 - 2021 Quarkslab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <algorithm>
#include <catch2/catch.hpp>
#include "APITest.h"
#include "inttypes.h"
#include "QBDI/Memory.hpp"
#include "QBDI/Platform.h"
#include "Utility/LogSys.h"
#include "Utility/String.h"
#if defined(QBDI_ARCH_X86)
#include "X86/VMTest_X86.h"
#elif defined(QBDI_ARCH_X86_64)
#include "X86_64/VMTest_X86_64.h"
#elif defined(QBDI_ARCH_ARM)
#include "ARM/VMTest_ARM.h"
#elif defined(QBDI_ARCH_AARCH64)
#include "AARCH64/VMTest_AARCH64.h"
#else
#error "Architecture not supported"
#endif
#define FAKE_RET_ADDR 0x666
QBDI_DISABLE_ASAN QBDI_NOINLINE int dummyFun0() { return 42; }
QBDI_DISABLE_ASAN QBDI_NOINLINE int dummyFun1(int arg0) { return arg0; }
QBDI_DISABLE_ASAN QBDI_NOINLINE int dummyFun4(int arg0, int arg1, int arg2,
int arg3) {
return arg0 + arg1 + arg2 + arg3;
}
QBDI_DISABLE_ASAN QBDI_NOINLINE int dummyFun5(int arg0, int arg1, int arg2,
int arg3, int arg4) {
return arg0 + arg1 + arg2 + arg3 + arg4;
}
QBDI_DISABLE_ASAN QBDI_NOINLINE int dummyFun8(int arg0, int arg1, int arg2,
int arg3, int arg4, int arg5,
int arg6, int arg7) {
return arg0 + arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7;
}
QBDI_DISABLE_ASAN QBDI_NOINLINE int dummyFunCall(int arg0) {
// use simple BUT multiplatform functions to test external calls
uint8_t *useless = (uint8_t *)QBDI::alignedAlloc(256, 16);
if (useless) {
*(int *)useless = arg0;
QBDI::alignedFree(useless);
}
return dummyFun1(arg0);
}
QBDI_DISABLE_ASAN QBDI_NOINLINE int dummyFunBB(int arg0, int arg1, int arg2,
int (*f0)(int), int (*f1)(int),
int (*f2)(int)) {
int r = 0;
if (arg0 & 1) {
r = f1(f0(arg1)) + arg2;
r ^= arg0;
} else {
r = f0(f1(arg2)) + arg1;
r ^= arg0;
}
r = f2(r + arg0 + arg1 + arg2);
if (arg0 & 2) {
r += f1(f0(arg2 + r)) + arg1;
r ^= arg0;
} else {
r += f0(f1(arg1 + r)) + arg2;
r ^= arg0;
}
return r;
}
TEST_CASE_METHOD(APITest, "VMTest-Call0") {
QBDI::simulateCall(state, FAKE_RET_ADDR);
vm.run((QBDI::rword)dummyFun0, (QBDI::rword)FAKE_RET_ADDR);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)42);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-Call1") {
QBDI::simulateCall(state, FAKE_RET_ADDR, {42});
vm.run((QBDI::rword)dummyFun1, (QBDI::rword)FAKE_RET_ADDR);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)dummyFun1(42));
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-Call4") {
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 5});
vm.run((QBDI::rword)dummyFun4, (QBDI::rword)FAKE_RET_ADDR);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)dummyFun4(1, 2, 3, 5));
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-Call5") {
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 5, 8});
vm.run((QBDI::rword)dummyFun5, (QBDI::rword)FAKE_RET_ADDR);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)dummyFun5(1, 2, 3, 5, 8));
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-Call8") {
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 5, 8, 13, 21, 34});
vm.run((QBDI::rword)dummyFun8, (QBDI::rword)FAKE_RET_ADDR);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)dummyFun8(1, 2, 3, 5, 8, 13, 21, 34));
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-ExternalCall") {
dummyFunCall(42);
QBDI::simulateCall(state, FAKE_RET_ADDR, {42});
vm.run((QBDI::rword)dummyFunCall, (QBDI::rword)FAKE_RET_ADDR);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)dummyFun1(42));
SUCCEED();
}
QBDI::VMAction countInstruction(QBDI::VMInstanceRef vm,
QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) {
*((uint32_t *)data) += 1;
return QBDI::VMAction::CONTINUE;
}
QBDI::VMAction evilCbk(QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) {
const QBDI::InstAnalysis *ana = vm->getInstAnalysis();
CHECK(ana->mnemonic != nullptr);
CHECK(ana->disassembly != nullptr);
CHECK(ana->operands == nullptr);
QBDI::rword *info = (QBDI::rword *)data;
QBDI::rword cval = QBDI_GPR_GET(gprState, QBDI::REG_RETURN);
// should never be reached (because we stop VM after value is incremented)
if (info[1] != 0) {
// if we failed this test, just return a fixed value
QBDI_GPR_SET(gprState, QBDI::REG_RETURN, 0x21);
}
// return register is being set with our return value
if (cval == (satanicFun(info[0]))) {
info[1]++;
return QBDI::VMAction::STOP;
}
return QBDI::VMAction::CONTINUE;
}
/* This test is used to ensure that addCodeAddrCB is not broken */
TEST_CASE_METHOD(APITest, "VMTest-Breakpoint") {
uint32_t counter = 0;
QBDI::rword retval = 0;
vm.addCodeAddrCB((QBDI::rword)dummyFun0, QBDI::InstPosition::PREINST,
countInstruction, &counter);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(counter == 1u);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstCallback") {
QBDI::rword info[2] = {42, 0};
QBDI::simulateCall(state, FAKE_RET_ADDR, {info[0]});
uint32_t instrId = vm.addCodeCB(QBDI::InstPosition::POSTINST, evilCbk, &info);
bool ran = vm.run((QBDI::rword)satanicFun, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)satanicFun(info[0]));
REQUIRE(info[1] == (QBDI::rword)1);
bool success = vm.deleteInstrumentation(instrId);
REQUIRE(success);
SUCCEED();
}
QBDI::VMAction evilMnemCbk(QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) {
QBDI::rword *info = (QBDI::rword *)data;
if (info[0] >= MNEM_COUNT)
return QBDI::VMAction::CONTINUE;
// get instruction metadata
const QBDI::InstAnalysis *ana =
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION | QBDI::ANALYSIS_OPERANDS);
// validate mnemonic
CHECKED_IF(QBDI::String::startsWith(MNEM_CMP, ana->mnemonic)) {
info[0]++; // CMP count
info[1]++;
// validate address
CHECKED_IF(ana->address >= (QBDI::rword)&satanicFun)
CHECKED_IF(ana->address < (((QBDI::rword)&satanicFun) + 0x100))
info[1]++;
// validate inst size
const struct TestInst ¤tInst = TestInsts[info[0] - 1];
#if defined(QBDI_ARCH_X86) || defined(QBDI_ARCH_X86_64)
CHECKED_IF(ana->instSize == currentInst.instSize) {
#else
{
#endif
info[1]++;
}
// validate instruction type (kinda...)
if (currentInst.isCompare) {
// CHECKED_IF doesn't support && operator
CHECKED_IF(!ana->isBranch)
CHECKED_IF(!ana->isCall)
CHECKED_IF(!ana->isReturn)
CHECKED_IF(ana->isCompare)
info[1]++;
}
CHECKED_IF(ana->flagsAccess == currentInst.flagsAccess) { info[1]++; }
// validate number of analyzed operands
CHECKED_IF(ana->numOperands == currentInst.numOperands) { info[1]++; }
// validate operands
CHECKED_IF(ana->operands != nullptr) {
info[1]++;
for (uint8_t idx = 0;
idx < std::min(ana->numOperands, currentInst.numOperands); idx++) {
const QBDI::OperandAnalysis &cmpOp = currentInst.operands[idx];
const QBDI::OperandAnalysis &op = ana->operands[idx];
CHECKED_IF(op.type == cmpOp.type) { info[1]++; }
if (op.type == QBDI::OPERAND_IMM) {
CHECKED_IF(op.value == cmpOp.value) { info[1]++; }
}
if (op.regName == nullptr && cmpOp.regName == nullptr) {
info[1]++;
} else {
CHECKED_IF(op.regName != nullptr)
CHECKED_IF(cmpOp.regName != nullptr)
CHECKED_IF(std::string(op.regName) == std::string(cmpOp.regName))
info[1]++;
}
CHECKED_IF(op.size == cmpOp.size) { info[1]++; }
CHECKED_IF(op.regCtxIdx == cmpOp.regCtxIdx) { info[1]++; }
CHECKED_IF(op.regOff == cmpOp.regOff) { info[1]++; }
CHECKED_IF(op.regAccess == cmpOp.regAccess) { info[1]++; }
}
}
}
return QBDI::VMAction::CONTINUE;
}
TEST_CASE_METHOD(APITest, "VMTest-MnemCallback") {
QBDI::rword info[3] = {0, 0, 42};
QBDI::rword retval = 0;
const char *noop = MNEM_CMP;
uint32_t instrId =
vm.addMnemonicCB(noop, QBDI::InstPosition::PREINST, evilMnemCbk, &info);
bool ran = vm.call(&retval, (QBDI::rword)satanicFun, {info[2]});
REQUIRE(ran);
CHECK(retval == (QBDI::rword)satanicFun(info[2]));
// TODO: try to find a way to support windows
#ifdef QBDI_PLATFORM_WINDOWS
CHECK(info[1] == (QBDI::rword)0);
#else
CHECK(info[0] == MNEM_COUNT);
CHECK(info[1] == (QBDI::rword)MNEM_VALIDATION);
#endif
bool success = vm.deleteInstrumentation(instrId);
REQUIRE(success);
SUCCEED();
}
QBDI::VMAction checkTransfer(QBDI::VMInstanceRef vm, const QBDI::VMState *state,
QBDI::GPRState *gprState, QBDI::FPRState *fprState,
void *data) {
int *s = (int *)data;
if (state->event == QBDI::VMEvent::EXEC_TRANSFER_CALL) {
REQUIRE((*s % 2) == 0);
REQUIRE(reinterpret_cast<QBDI::rword>(dummyFun1) == state->sequenceStart);
*s += 1;
} else if (state->event == QBDI::VMEvent::EXEC_TRANSFER_RETURN) {
REQUIRE((*s % 2) == 1);
REQUIRE(reinterpret_cast<QBDI::rword>(dummyFun1) == state->sequenceStart);
*s += 1;
}
return QBDI::VMAction::CONTINUE;
}
TEST_CASE_METHOD(APITest, "VMTest-VMEvent_ExecTransfer") {
int s = 0;
bool instrumented = vm.addInstrumentedModuleFromAddr(
reinterpret_cast<QBDI::rword>(dummyFunBB));
REQUIRE(instrumented);
vm.removeInstrumentedRange(reinterpret_cast<QBDI::rword>(dummyFun1),
reinterpret_cast<QBDI::rword>(dummyFun1) + 1);
uint32_t id = vm.addVMEventCB(QBDI::VMEvent::EXEC_TRANSFER_CALL,
checkTransfer, (void *)&s);
REQUIRE(id != QBDI::INVALID_EVENTID);
id = vm.addVMEventCB(QBDI::VMEvent::EXEC_TRANSFER_RETURN, checkTransfer,
(void *)&s);
REQUIRE(id != QBDI::INVALID_EVENTID);
QBDI::rword retval;
bool ran = vm.call(&retval, reinterpret_cast<QBDI::rword>(dummyFunBB),
{0, 0, 0, reinterpret_cast<QBDI::rword>(dummyFun1),
reinterpret_cast<QBDI::rword>(dummyFun1),
reinterpret_cast<QBDI::rword>(dummyFun1)});
REQUIRE(ran);
REQUIRE(retval == (QBDI::rword)0);
REQUIRE(10 == s);
vm.deleteAllInstrumentations();
}
struct CheckBasicBlockData {
bool waitingEnd;
QBDI::rword BBStart;
QBDI::rword BBEnd;
size_t count;
};
static QBDI::VMAction checkBasicBlock(QBDI::VMInstanceRef vm,
const QBDI::VMState *vmState,
QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data_) {
CheckBasicBlockData *data = static_cast<CheckBasicBlockData *>(data_);
CHECK((vmState->event & (QBDI::BASIC_BLOCK_ENTRY | QBDI::BASIC_BLOCK_EXIT)) !=
0);
CHECK((vmState->event & (QBDI::BASIC_BLOCK_ENTRY | QBDI::BASIC_BLOCK_EXIT)) !=
(QBDI::BASIC_BLOCK_ENTRY | QBDI::BASIC_BLOCK_EXIT));
if (vmState->event & QBDI::BASIC_BLOCK_ENTRY) {
CHECK_FALSE(data->waitingEnd);
CHECK(vmState->basicBlockStart == vmState->sequenceStart);
*data = {true, vmState->basicBlockStart, vmState->basicBlockEnd,
data->count};
} else if (vmState->event & QBDI::BASIC_BLOCK_EXIT) {
CHECK(data->waitingEnd);
CHECK(data->BBStart == vmState->basicBlockStart);
CHECK(data->BBEnd == vmState->basicBlockEnd);
CHECK(vmState->basicBlockEnd == vmState->sequenceEnd);
data->waitingEnd = false;
data->count++;
}
return QBDI::VMAction::CONTINUE;
}
TEST_CASE_METHOD(APITest, "VMTest-VMEvent_BasicBlock") {
CheckBasicBlockData data{false, 0, 0, 0};
vm.addVMEventCB(QBDI::BASIC_BLOCK_ENTRY | QBDI::BASIC_BLOCK_EXIT,
checkBasicBlock, &data);
// backup GPRState to have the same state before each run
QBDI::GPRState backup = *(vm.getGPRState());
for (QBDI::rword j = 0; j < 4; j++) {
for (QBDI::rword i = 0; i < 8; i++) {
QBDI_DEBUG("Begin Loop iteration {} {}", j, i);
vm.setGPRState(&backup);
data.waitingEnd = false;
data.count = 0;
QBDI::rword retval;
bool ran =
vm.call(&retval, reinterpret_cast<QBDI::rword>(dummyFunBB),
{i ^ j, 5, 13, reinterpret_cast<QBDI::rword>(dummyFun1),
reinterpret_cast<QBDI::rword>(dummyFun1),
reinterpret_cast<QBDI::rword>(dummyFun1)});
CHECK(ran);
CHECK_FALSE(data.waitingEnd);
CHECK(data.count != 0);
}
vm.clearAllCache();
}
}
TEST_CASE_METHOD(APITest, "VMTest-CacheInvalidation") {
uint32_t count1 = 0;
uint32_t count2 = 0;
bool instrumented =
vm.addInstrumentedModuleFromAddr((QBDI::rword)&dummyFunCall);
REQUIRE(instrumented);
uint32_t instr1 =
vm.addCodeCB(QBDI::InstPosition::POSTINST, countInstruction, &count1);
count1 = 0;
count2 = 0;
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 4});
bool ran = vm.run((QBDI::rword)dummyFun4, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)10);
REQUIRE((uint32_t)0 != count1);
REQUIRE((uint32_t)0 == count2);
uint32_t instr2 = vm.addCodeRangeCB(
(QBDI::rword)&dummyFun5, ((QBDI::rword)&dummyFun5) + 64,
QBDI::InstPosition::POSTINST, countInstruction, &count2);
count1 = 0;
count2 = 0;
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 4, 5});
ran = vm.run((QBDI::rword)dummyFun5, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)15);
REQUIRE((uint32_t)0 != count1);
REQUIRE((uint32_t)0 != count2);
vm.deleteInstrumentation(instr1);
count1 = 0;
count2 = 0;
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 4});
ran = vm.run((QBDI::rword)dummyFun4, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)10);
REQUIRE((uint32_t)0 == count1);
REQUIRE((uint32_t)0 == count2);
count1 = 0;
count2 = 0;
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 4, 5});
ran = vm.run((QBDI::rword)dummyFun5, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)15);
REQUIRE((uint32_t)0 == count1);
REQUIRE((uint32_t)0 != count2);
instr1 =
vm.addCodeCB(QBDI::InstPosition::POSTINST, countInstruction, &count1);
count1 = 0;
count2 = 0;
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 4, 5});
ran = vm.run((QBDI::rword)dummyFun5, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)15);
REQUIRE((uint32_t)0 != count1);
REQUIRE((uint32_t)0 != count2);
vm.deleteInstrumentation(instr2);
count1 = 0;
count2 = 0;
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 4});
ran = vm.run((QBDI::rword)dummyFun4, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)10);
REQUIRE((uint32_t)0 != count1);
REQUIRE((uint32_t)0 == count2);
count1 = 0;
count2 = 0;
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 4, 5});
ran = vm.run((QBDI::rword)dummyFun5, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)15);
REQUIRE((uint32_t)0 != count1);
REQUIRE((uint32_t)0 == count2);
}
struct FunkyInfo {
uint32_t instID;
uint32_t count;
};
QBDI::VMAction funkyCountInstruction(QBDI::VMInstanceRef vm,
QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) {
FunkyInfo *info = (FunkyInfo *)data;
const QBDI::InstAnalysis *instAnalysis1 =
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION);
vm->deleteInstrumentation(info->instID);
const QBDI::InstAnalysis *instAnalysis2 =
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION);
info->instID = vm->addCodeRangeCB(QBDI_GPR_GET(gprState, QBDI::REG_PC),
QBDI_GPR_GET(gprState, QBDI::REG_PC) + 10,
QBDI::InstPosition::POSTINST,
funkyCountInstruction, data);
const QBDI::InstAnalysis *instAnalysis3 =
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION);
// instAnalysis1, instAnalysis2 and instAnalysis3 should be the same pointer
// because the cache flush initiated by deleteInstrumentation and
// addCodeRangeCB is delayed.
if (instAnalysis1 == instAnalysis2 && instAnalysis2 == instAnalysis3) {
info->count += 1;
}
// instAnalysis3 should not have disassembly information, but instAnalysis4
// and instAnalysis5 should.
CHECK(instAnalysis3->disassembly == nullptr);
CHECK(instAnalysis3->operands == nullptr);
const QBDI::InstAnalysis *instAnalysis4 = vm->getInstAnalysis(
QBDI::ANALYSIS_INSTRUCTION | QBDI::ANALYSIS_DISASSEMBLY);
CHECK(instAnalysis4->disassembly != nullptr);
CHECK(instAnalysis4->operands == nullptr);
const QBDI::InstAnalysis *instAnalysis5 =
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION);
CHECK(instAnalysis5->disassembly != nullptr);
CHECK(instAnalysis5->operands == nullptr);
return QBDI::VMAction::BREAK_TO_VM;
}
TEST_CASE_METHOD(APITest, "VMTest-DelayedCacheFlush") {
uint32_t count = 0;
FunkyInfo info = FunkyInfo{0, 0};
bool instrumented =
vm.addInstrumentedModuleFromAddr((QBDI::rword)&dummyFunCall);
REQUIRE(instrumented);
vm.addCodeCB(QBDI::InstPosition::POSTINST, countInstruction, &count);
info.instID = vm.addCodeRangeCB(
(QBDI::rword)dummyFun4, ((QBDI::rword)dummyFun4) + 10,
QBDI::InstPosition::POSTINST, funkyCountInstruction, &info);
QBDI::simulateCall(state, FAKE_RET_ADDR, {1, 2, 3, 4});
bool ran = vm.run((QBDI::rword)dummyFun4, (QBDI::rword)FAKE_RET_ADDR);
REQUIRE(ran);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)10);
REQUIRE(count == info.count);
}
struct PriorityDataCall {
QBDI::rword addr;
QBDI::InstPosition pos;
int priority;
PriorityDataCall(QBDI::rword addr, QBDI::InstPosition pos, int priority)
: addr(addr), pos(pos), priority(priority) {}
};
static std::vector<QBDI::InstrRuleDataCBK>
priorityInstrCB(QBDI::VMInstanceRef vm, const QBDI::InstAnalysis *inst,
void *data_) {
std::vector<QBDI::InstrRuleDataCBK> r;
r.emplace_back(
QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::PREINST, -100);
return QBDI::VMAction::CONTINUE;
},
data_, -100);
r.emplace_back(
QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::POSTINST, 0);
return QBDI::VMAction::CONTINUE;
},
data_, 0);
r.emplace_back(
QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::POSTINST, 100);
return QBDI::VMAction::CONTINUE;
},
data_, 100);
r.emplace_back(
QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::PREINST, 100);
return QBDI::VMAction::CONTINUE;
},
data_, 100);
r.emplace_back(
QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::PREINST, 0);
return QBDI::VMAction::CONTINUE;
},
data_, 0);
r.emplace_back(
QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::POSTINST, -100);
return QBDI::VMAction::CONTINUE;
},
data_, -100);
return r;
}
TEST_CASE_METHOD(APITest, "VMTest-Priority") {
std::vector<PriorityDataCall> callList;
QBDI::rword retval = 0;
vm.addCodeCB(
QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::PREINST, -10);
return QBDI::VMAction::CONTINUE;
},
&callList, -10);
vm.addCodeCB(
QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::POSTINST, -67);
return QBDI::VMAction::CONTINUE;
},
&callList, -67);
vm.addCodeCB(
QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::POSTINST, 56);
return QBDI::VMAction::CONTINUE;
},
&callList, 56);
vm.addInstrRule(priorityInstrCB, QBDI::ANALYSIS_INSTRUCTION, &callList);
vm.addCodeCB(
QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::PREINST, 27);
return QBDI::VMAction::CONTINUE;
},
&callList, 27);
vm.addCodeCB(
QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((std::vector<PriorityDataCall> *)data)
->emplace_back(
vm->getInstAnalysis(QBDI::ANALYSIS_INSTRUCTION)->address,
QBDI::InstPosition::PREINST, -77);
return QBDI::VMAction::CONTINUE;
},
&callList, -77);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(callList.size() >= 11);
for (size_t i = 1; i < callList.size(); i++) {
if (callList[i - 1].addr == callList[i].addr) {
if (callList[i - 1].pos == callList[i].pos) {
REQUIRE(callList[i - 1].priority >= callList[i].priority);
} else {
REQUIRE(callList[i - 1].pos == QBDI::InstPosition::PREINST);
REQUIRE(callList[i].pos == QBDI::InstPosition::POSTINST);
}
}
}
SUCCEED();
}
struct SkipTestData {
uint8_t cbpre1;
uint8_t cbpre2;
uint8_t cbpre3;
uint8_t cbpost;
uint8_t cbnumpre;
uint8_t cbnumpost;
};
TEST_CASE_METHOD(APITest, "VMTest-SKIP_INST") {
SkipTestData data = {0};
QBDI::rword addr = genASM(SKIPTESTASM);
vm.addCodeAddrCB(
addr, QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbpre1++;
return QBDI::VMAction::CONTINUE;
},
&data, 100);
vm.addCodeCB(
QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbnumpre++;
return QBDI::VMAction::CONTINUE;
},
&data, 0);
vm.addCodeAddrCB(
addr, QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbpre2++;
return QBDI::VMAction::SKIP_INST;
},
&data, -100);
vm.addCodeAddrCB(
addr, QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbpre3++;
return QBDI::VMAction::CONTINUE;
},
&data, -200);
vm.addCodeAddrCB(
addr, QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbpost++;
return QBDI::VMAction::CONTINUE;
},
&data, 0);
vm.addCodeCB(
QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbnumpost++;
return QBDI::VMAction::CONTINUE;
},
&data, 0);
QBDI::rword retval = 0;
vm.call(&retval, (QBDI::rword)addr);
REQUIRE(data.cbpre1 == 1);
REQUIRE(data.cbpre2 == 1);
REQUIRE(data.cbpre3 == 0);
REQUIRE(data.cbpost == 1);
REQUIRE(data.cbnumpre == 3);
REQUIRE(data.cbnumpost == 3);
}
TEST_CASE_METHOD(APITest, "VMTest-SKIP_PATCH") {
SkipTestData data = {0};
QBDI::rword addr = genASM(SKIPTESTASM);
vm.addCodeAddrCB(
addr, QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbpre1++;
return QBDI::VMAction::CONTINUE;
},
&data, 100);
vm.addCodeCB(
QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbnumpre++;
return QBDI::VMAction::CONTINUE;
},
&data, 0);
vm.addCodeAddrCB(
addr, QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbpre2++;
return QBDI::VMAction::SKIP_PATCH;
},
&data, -100);
vm.addCodeAddrCB(
addr, QBDI::InstPosition::PREINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbpre3++;
return QBDI::VMAction::CONTINUE;
},
&data, -200);
vm.addCodeAddrCB(
addr, QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbpost++;
return QBDI::VMAction::CONTINUE;
},
&data, 0);
vm.addCodeCB(
QBDI::InstPosition::POSTINST,
[](QBDI::VMInstanceRef vm, QBDI::GPRState *gprState,
QBDI::FPRState *fprState, void *data) -> QBDI::VMAction {
((SkipTestData *)data)->cbnumpost++;
return QBDI::VMAction::CONTINUE;
},
&data, 0);
QBDI::rword retval = 0;
vm.call(&retval, (QBDI::rword)addr);
REQUIRE(data.cbpre1 == 1);
REQUIRE(data.cbpre2 == 1);
REQUIRE(data.cbpre3 == 0);
REQUIRE(data.cbpost == 0);
REQUIRE(data.cbnumpre == 3);
REQUIRE(data.cbnumpost == 2);
}
// Test copy/move constructor/assignment operator
struct MoveCallbackStruct {
QBDI::VMInstanceRef expectedRef;
bool allowedNewBlock;
bool reachEventCB;
bool reachInstCB;
bool reachInstrumentCB;
bool reachCB2;
};
static QBDI::VMAction allowedNewBlock(QBDI::VMInstanceRef vm,
const QBDI::VMState *state,
QBDI::GPRState *, QBDI::FPRState *,
void *data_) {
MoveCallbackStruct *data = static_cast<MoveCallbackStruct *>(data_);
CHECK(data->expectedRef == vm);
CHECK(
(data->allowedNewBlock or ((state->event & QBDI::BASIC_BLOCK_NEW) == 0)));
data->reachEventCB = true;
return QBDI::VMAction::CONTINUE;
}
static std::vector<QBDI::InstrRuleDataCBK>
instrumentCopyCB(QBDI::VMInstanceRef vm, const QBDI::InstAnalysis *inst,
void *data_) {
MoveCallbackStruct *data = static_cast<MoveCallbackStruct *>(data_);
CHECK(data->expectedRef == vm);
CHECK(data->allowedNewBlock);
data->reachInstrumentCB = true;
return {};
}
static QBDI::VMAction verifyVMRef(QBDI::VMInstanceRef vm, QBDI::GPRState *,
QBDI::FPRState *, void *data_) {
MoveCallbackStruct *data = static_cast<MoveCallbackStruct *>(data_);
CHECK(data->expectedRef == vm);
data->reachInstCB = true;
return QBDI::VMAction::CONTINUE;
}
static QBDI::VMAction verifyCB2(QBDI::VMInstanceRef vm, QBDI::GPRState *,
QBDI::FPRState *, void *data_) {
MoveCallbackStruct *data = static_cast<MoveCallbackStruct *>(data_);
CHECK(data->expectedRef == vm);
data->reachCB2 = true;
return QBDI::VMAction::CONTINUE;
}
TEST_CASE("VMTest-MoveConstructor") {
APITest vm1_;
std::unique_ptr<QBDI::VM> vm1 = std::make_unique<QBDI::VM>(vm1_.vm);
QBDI::VM *vm = vm1.get();
MoveCallbackStruct data{vm, true, false, false, false, false};
bool instrumented =
vm->addInstrumentedModuleFromAddr((QBDI::rword)&dummyFunCall);
REQUIRE(instrumented);
vm->addCodeCB(QBDI::InstPosition::POSTINST, verifyVMRef, &data);
vm->addInstrRule(instrumentCopyCB, QBDI::ANALYSIS_INSTRUCTION, &data);
vm->addVMEventCB(QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT |
QBDI::BASIC_BLOCK_NEW,
allowedNewBlock, &data);
QBDI::rword retvalue;
QBDI_DEBUG("Execute dummyFun1 with the original VM");
vm->call(&retvalue, (QBDI::rword)dummyFun1, {350});
REQUIRE(retvalue == 350);
REQUIRE(data.reachEventCB);
REQUIRE(data.reachInstCB);
REQUIRE(data.reachInstrumentCB);
data.reachEventCB = false;
data.reachInstCB = false;
data.reachInstrumentCB = false;
data.allowedNewBlock = false;
REQUIRE(vm == data.expectedRef);
// move vm
QBDI_DEBUG("Move the VM");
QBDI::VM movedVM(std::move(*vm));
vm = nullptr;
vm1.reset();
REQUIRE(vm1.get() == nullptr);
REQUIRE(data.expectedRef != &movedVM);
data.expectedRef = &movedVM;
QBDI_DEBUG("Execute with the moved VM");
movedVM.call(&retvalue, (QBDI::rword)dummyFun1, {780});
REQUIRE(retvalue == 780);
REQUIRE(data.reachEventCB);
REQUIRE(data.reachInstCB);
REQUIRE_FALSE(data.reachInstrumentCB);
data.allowedNewBlock = true;
movedVM.precacheBasicBlock((QBDI::rword)dummyFun0);
REQUIRE(data.reachInstrumentCB);
}
TEST_CASE("VMTest-CopyConstructor") {
APITest vm1;
QBDI::VM *vm = &vm1.vm;
MoveCallbackStruct data{vm, true, false, false, false, false};
bool instrumented =
vm->addInstrumentedModuleFromAddr((QBDI::rword)&dummyFunCall);
REQUIRE(instrumented);
vm->addCodeCB(QBDI::InstPosition::POSTINST, verifyVMRef, &data);
vm->addInstrRule(instrumentCopyCB, QBDI::ANALYSIS_INSTRUCTION, &data);
vm->addVMEventCB(QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT |
QBDI::BASIC_BLOCK_NEW,
allowedNewBlock, &data);
QBDI::rword retvalue;
QBDI_DEBUG("Execute dummyFun1 with the original VM");
vm->call(&retvalue, (QBDI::rword)dummyFun1, {350});
REQUIRE(retvalue == 350);
REQUIRE(data.reachEventCB);
REQUIRE(data.reachInstCB);
REQUIRE(data.reachInstrumentCB);
data.reachEventCB = false;
data.reachInstCB = false;
data.reachInstrumentCB = false;
data.allowedNewBlock = false;
// copy vm
QBDI_DEBUG("Copy the VM");
QBDI::VM movedVM(*vm);
REQUIRE(data.expectedRef != &movedVM);
QBDI_DEBUG("Execute second time with the original VM");
vm->call(&retvalue, (QBDI::rword)dummyFun1, {620});
REQUIRE(retvalue == 620);
REQUIRE(data.reachEventCB);
REQUIRE(data.reachInstCB);
REQUIRE_FALSE(data.reachInstrumentCB);
data.reachEventCB = false;
data.reachInstCB = false;
data.reachInstrumentCB = false;
data.allowedNewBlock = true;
data.expectedRef = &movedVM;
QBDI_DEBUG("Execute with the copied VM");
movedVM.call(&retvalue, (QBDI::rword)dummyFun1, {780});
REQUIRE(retvalue == 780);
REQUIRE(data.reachEventCB);
REQUIRE(data.reachInstCB);
REQUIRE(data.reachInstrumentCB);
}
TEST_CASE("VMTest-MoveAssignmentOperator") {
APITest vm1__;
APITest vm2__;
std::unique_ptr<QBDI::VM> vm1_ = std::make_unique<QBDI::VM>(vm1__.vm);
std::unique_ptr<QBDI::VM> vm2_ = std::make_unique<QBDI::VM>(vm2__.vm);
QBDI::VM *vm1 = vm1_.get();
QBDI::VM *vm2 = vm2_.get();
REQUIRE(vm1 != vm2);
MoveCallbackStruct data1{vm1, true, false, false, false, false};
MoveCallbackStruct data2{vm2, true, false, false, false, false};
bool instrumented =
vm1->addInstrumentedModuleFromAddr((QBDI::rword)&dummyFunCall);
REQUIRE(instrumented);
instrumented = vm2->addInstrumentedModuleFromAddr((QBDI::rword)&dummyFunCall);
REQUIRE(instrumented);
vm1->addCodeCB(QBDI::InstPosition::POSTINST, verifyVMRef, &data1);
vm1->addInstrRule(instrumentCopyCB, QBDI::ANALYSIS_INSTRUCTION, &data1);
vm1->addVMEventCB(QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT |
QBDI::BASIC_BLOCK_NEW,
allowedNewBlock, &data1);
vm2->addCodeCB(QBDI::InstPosition::POSTINST, verifyVMRef, &data2);
vm2->addInstrRule(instrumentCopyCB, QBDI::ANALYSIS_INSTRUCTION, &data2);
vm2->addVMEventCB(QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT |
QBDI::BASIC_BLOCK_NEW,
allowedNewBlock, &data2);
QBDI::rword retvalue;
vm1->call(&retvalue, (QBDI::rword)dummyFun1, {350});
REQUIRE(retvalue == 350);
REQUIRE(data1.reachEventCB);
REQUIRE(data1.reachInstCB);
REQUIRE(data1.reachInstrumentCB);
data1.reachEventCB = false;
data1.reachInstCB = false;
data1.reachInstrumentCB = false;
data1.allowedNewBlock = false;
vm2->call(&retvalue, (QBDI::rword)dummyFun1, {670});
REQUIRE(retvalue == 670);
REQUIRE(data2.reachEventCB);
REQUIRE(data2.reachInstCB);
REQUIRE(data2.reachInstrumentCB);
data2.reachEventCB = false;
data2.reachInstCB = false;
data2.reachInstrumentCB = false;
data2.allowedNewBlock = false;
data1.expectedRef = vm2;
data2.expectedRef = nullptr;
// move vm
*vm2 = std::move(*vm1);
vm1 = nullptr;
vm1_.reset();
REQUIRE(vm1_.get() == nullptr);
vm2->call(&retvalue, (QBDI::rword)dummyFun1, {780});
REQUIRE(retvalue == 780);
REQUIRE(data1.reachEventCB);
REQUIRE(data1.reachInstCB);
REQUIRE_FALSE(data1.reachInstrumentCB);
REQUIRE_FALSE(data2.reachEventCB);
REQUIRE_FALSE(data2.reachInstCB);
REQUIRE_FALSE(data2.reachInstrumentCB);
data1.allowedNewBlock = true;
vm2->precacheBasicBlock((QBDI::rword)dummyFun0);
REQUIRE(data1.reachInstrumentCB);
}
TEST_CASE("VMTest-CopyAssignmentOperator") {
APITest vm1_;
APITest vm2_;
QBDI::VM *vm1 = &vm1_.vm;
QBDI::VM *vm2 = &vm2_.vm;
REQUIRE(vm1 != vm2);
MoveCallbackStruct data1{vm1, true, false, false, false, false};
MoveCallbackStruct data2{vm2, true, false, false, false, false};
bool instrumented =
vm1->addInstrumentedModuleFromAddr((QBDI::rword)&dummyFunCall);
REQUIRE(instrumented);
instrumented = vm2->addInstrumentedModuleFromAddr((QBDI::rword)&dummyFunCall);
REQUIRE(instrumented);
vm1->addCodeCB(QBDI::InstPosition::POSTINST, verifyVMRef, &data1);
vm1->addCodeCB(QBDI::InstPosition::POSTINST, verifyCB2, &data1);
vm1->addInstrRule(instrumentCopyCB, QBDI::ANALYSIS_INSTRUCTION, &data1);
vm1->addVMEventCB(QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT |
QBDI::BASIC_BLOCK_NEW,
allowedNewBlock, &data1);
vm2->addCodeCB(QBDI::InstPosition::POSTINST, verifyVMRef, &data2);
vm2->addInstrRule(instrumentCopyCB, QBDI::ANALYSIS_INSTRUCTION, &data2);
vm2->addVMEventCB(QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT |
QBDI::BASIC_BLOCK_NEW,
allowedNewBlock, &data2);
QBDI::rword retvalue;
vm1->call(&retvalue, (QBDI::rword)dummyFun1, {350});
REQUIRE(retvalue == 350);
REQUIRE(data1.reachEventCB);
REQUIRE(data1.reachInstCB);
REQUIRE(data1.reachInstrumentCB);
REQUIRE(data1.reachCB2);
data1.reachEventCB = false;
data1.reachInstCB = false;
data1.reachInstrumentCB = false;
data1.allowedNewBlock = false;
data1.reachCB2 = false;
vm2->call(&retvalue, (QBDI::rword)dummyFun1, {670});
REQUIRE(retvalue == 670);
REQUIRE(data2.reachEventCB);
REQUIRE(data2.reachInstCB);
REQUIRE(data2.reachInstrumentCB);
REQUIRE_FALSE(data2.reachCB2);
data2.reachEventCB = false;
data2.reachInstCB = false;
data2.reachInstrumentCB = false;
data2.allowedNewBlock = false;
data2.expectedRef = nullptr;
// copy vm
*vm2 = *vm1;
vm1->call(&retvalue, (QBDI::rword)dummyFun1, {780});
REQUIRE(retvalue == 780);
REQUIRE(data1.reachEventCB);
REQUIRE(data1.reachInstCB);
REQUIRE_FALSE(data1.reachInstrumentCB);
REQUIRE(data1.reachCB2);
REQUIRE_FALSE(data2.reachEventCB);
REQUIRE_FALSE(data2.reachInstCB);
REQUIRE_FALSE(data2.reachCB2);
REQUIRE_FALSE(data2.reachInstrumentCB);
data1.reachEventCB = false;
data1.reachInstCB = false;
data1.reachInstrumentCB = false;
data1.allowedNewBlock = true;
data1.expectedRef = vm2;
data1.reachCB2 = false;
vm2->call(&retvalue, (QBDI::rword)dummyFun1, {567});
REQUIRE(retvalue == 567);
REQUIRE(data1.reachEventCB);
REQUIRE(data1.reachInstCB);
REQUIRE(data1.reachInstrumentCB);
REQUIRE(data1.reachCB2);
REQUIRE_FALSE(data2.reachEventCB);
REQUIRE_FALSE(data2.reachInstCB);
REQUIRE_FALSE(data2.reachCB2);
REQUIRE_FALSE(data2.reachInstrumentCB);
}
TEST_CASE_METHOD(APITest, "VMTest-VMEventLambda-VMcpy") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::VMCbLambda cbk = [&cbCalled](QBDI::VMInstanceRef, const QBDI::VMState *,
QBDI::GPRState *, QBDI::FPRState *) {
cbCalled = true;
return QBDI::VMAction::CONTINUE;
};
vm.addVMEventCB(
QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT | QBDI::BASIC_BLOCK_NEW, cbk);
// copy constructor
QBDI::VM vm2 = vm;
// copy operator
QBDI::VM vm3;
vm3.precacheBasicBlock((QBDI::rword)dummyFun0);
vm3 = vm;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm2.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm3.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstrRuleCbLambda-VMCpy") {
QBDI::rword retval;
bool cbCalled = false;
vm.addInstrRule(
[&cbCalled](QBDI::VMInstanceRef, const QBDI::InstAnalysis *)
-> std::vector<QBDI::InstrRuleDataCBK> {
cbCalled = true;
return {};
},
QBDI::ANALYSIS_INSTRUCTION);
// copy constructor
QBDI::VM vm2 = vm;
// copy operator
QBDI::VM vm3;
vm3.precacheBasicBlock((QBDI::rword)dummyFun0);
vm3 = vm;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm2.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm3.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
}
TEST_CASE_METHOD(APITest, "VMTest-InstCbLambda-VMCpy") {
QBDI::rword retval;
bool cbCalled = false;
vm.addCodeCB(
QBDI::InstPosition::PREINST,
[&cbCalled](QBDI::VMInstanceRef, QBDI::GPRState *, QBDI::FPRState *) {
cbCalled = true;
return QBDI::VMAction::CONTINUE;
});
// copy constructor
QBDI::VM vm2 = vm;
// copy operator
QBDI::VM vm3;
vm3.precacheBasicBlock((QBDI::rword)dummyFun0);
vm3 = vm;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm2.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm3.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
}
TEST_CASE_METHOD(APITest, "VMTest-VMEventLambda") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::VMCbLambda cbk = [&cbCalled](QBDI::VMInstanceRef, const QBDI::VMState *,
QBDI::GPRState *, QBDI::FPRState *) {
cbCalled = true;
return QBDI::VMAction::CONTINUE;
};
vm.addVMEventCB(
QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT | QBDI::BASIC_BLOCK_NEW, cbk);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm.addVMEventCB(QBDI::SEQUENCE_ENTRY | QBDI::SEQUENCE_EXIT |
QBDI::BASIC_BLOCK_NEW,
std::move(cbk));
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstrRuleCbLambda-addInstrRule") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::InstrRuleCbLambda cbk =
[&cbCalled](
QBDI::VMInstanceRef,
const QBDI::InstAnalysis *) -> std::vector<QBDI::InstrRuleDataCBK> {
cbCalled = true;
return {};
};
vm.addInstrRule(cbk, QBDI::ANALYSIS_INSTRUCTION);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm.addInstrRule(std::move(cbk), QBDI::ANALYSIS_INSTRUCTION);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstrRuleCbLambda-addInstrRuleRange") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::InstrRuleCbLambda cbk =
[&cbCalled](
QBDI::VMInstanceRef,
const QBDI::InstAnalysis *) -> std::vector<QBDI::InstrRuleDataCBK> {
cbCalled = true;
return {};
};
vm.addInstrRuleRange((QBDI::rword)dummyFun0, (QBDI::rword)dummyFun0 + 0x100,
cbk, QBDI::ANALYSIS_INSTRUCTION);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm.addInstrRuleRange((QBDI::rword)dummyFun0, (QBDI::rword)dummyFun0 + 0x100,
std::move(cbk), QBDI::ANALYSIS_INSTRUCTION);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstrRuleCbLambda-addInstrRuleRangeSet") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::InstrRuleCbLambda cbk =
[&cbCalled](
QBDI::VMInstanceRef,
const QBDI::InstAnalysis *) -> std::vector<QBDI::InstrRuleDataCBK> {
cbCalled = true;
return {};
};
QBDI::RangeSet<QBDI::rword> s;
s.add({(QBDI::rword)dummyFun0, (QBDI::rword)dummyFun0 + 0x100});
vm.addInstrRuleRangeSet(s, cbk, QBDI::ANALYSIS_INSTRUCTION);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm.addInstrRuleRangeSet(s, std::move(cbk), QBDI::ANALYSIS_INSTRUCTION);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstCbLambda-addMnemonicCB") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::InstCbLambda cbk = [&cbCalled](QBDI::VMInstanceRef, QBDI::GPRState *,
QBDI::FPRState *) {
cbCalled = true;
return QBDI::VMAction::CONTINUE;
};
vm.addMnemonicCB("*", QBDI::InstPosition::PREINST, cbk);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm.addMnemonicCB("*", QBDI::InstPosition::PREINST, std::move(cbk));
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstCbLambda-addCodeCB") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::InstCbLambda cbk = [&cbCalled](QBDI::VMInstanceRef, QBDI::GPRState *,
QBDI::FPRState *) {
cbCalled = true;
return QBDI::VMAction::CONTINUE;
};
vm.addCodeCB(QBDI::InstPosition::PREINST, cbk);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm.addCodeCB(QBDI::InstPosition::PREINST, std::move(cbk));
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstCbLambda-addCodeAddrCB") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::InstCbLambda cbk = [&cbCalled](QBDI::VMInstanceRef, QBDI::GPRState *,
QBDI::FPRState *) {
cbCalled = true;
return QBDI::VMAction::CONTINUE;
};
vm.addCodeAddrCB((QBDI::rword)dummyFun0, QBDI::InstPosition::PREINST, cbk);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm.addCodeAddrCB((QBDI::rword)dummyFun0, QBDI::InstPosition::PREINST,
std::move(cbk));
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstCbLambda-addCodeRangeCB") {
QBDI::rword retval;
bool cbCalled = false;
QBDI::InstCbLambda cbk = [&cbCalled](QBDI::VMInstanceRef, QBDI::GPRState *,
QBDI::FPRState *) {
cbCalled = true;
return QBDI::VMAction::CONTINUE;
};
vm.addCodeRangeCB((QBDI::rword)dummyFun0, (QBDI::rword)dummyFun0 + 0x100,
QBDI::InstPosition::PREINST, cbk);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
cbCalled = false;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
vm.addCodeRangeCB((QBDI::rword)dummyFun0, (QBDI::rword)dummyFun0 + 0x100,
QBDI::InstPosition::PREINST, std::move(cbk));
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InstCbLambda-InstrRuleDataCBK") {
QBDI::rword retval;
bool cbCalled = false;
uint32_t count1 = 0;
uint32_t count2 = 0;
uint32_t *count = &count1;
QBDI::InstrRuleCbLambda cbk =
[&cbCalled, &count](
QBDI::VMInstanceRef,
const QBDI::InstAnalysis *) -> std::vector<QBDI::InstrRuleDataCBK> {
return {{QBDI::InstPosition::PREINST,
[&cbCalled, count](QBDI::VMInstanceRef, QBDI::GPRState *,
QBDI::FPRState *) {
cbCalled = true;
(*count)++;
return QBDI::VMAction::CONTINUE;
}}};
};
vm.addInstrRule(cbk, QBDI::ANALYSIS_INSTRUCTION);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
REQUIRE(count1 != 0);
REQUIRE(count2 == 0);
uint32_t backcount1 = count1;
cbCalled = false;
count1 = 0;
count = &count2;
vm.deleteAllInstrumentations();
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(!cbCalled);
REQUIRE(count1 == 0);
REQUIRE(count2 == 0);
vm.addInstrRule(std::move(cbk), QBDI::ANALYSIS_INSTRUCTION);
vm.call(&retval, (QBDI::rword)dummyFun0);
REQUIRE(retval == (QBDI::rword)42);
REQUIRE(cbCalled);
REQUIRE(count1 == 0);
REQUIRE(count2 == backcount1);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-InvalidInstruction") {
auto tc = TestCode["VMTest-InvalidInstruction"];
auto code = tc.code;
if (code.empty()) {
return;
}
auto start = (QBDI::rword)code.data();
auto stop = (QBDI::rword)(code.data() + code.size());
QBDI::simulateCall(state, FAKE_RET_ADDR);
// Instrument the whole code but only execute what is valid
vm.addInstrumentedRange(start, stop);
bool ran = vm.run(start, start + tc.size);
REQUIRE(ran);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-SelfModifyingCode1") {
auto tc = TestCode["VMTest-SelfModifyingCode1"];
auto code = tc.code;
if (code.empty()) {
return;
}
auto start = (QBDI::rword)code.data();
auto stop = (QBDI::rword)(code.data() + code.size());
QBDI::simulateCall(state, FAKE_RET_ADDR);
vm.addInstrumentedRange(start, stop);
bool ran = vm.run(start, FAKE_RET_ADDR);
REQUIRE(ran);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)42);
SUCCEED();
}
TEST_CASE_METHOD(APITest, "VMTest-SelfModifyingCode2") {
/**
* Test a strategy to handle self modifying code. Add a callback on write in
* the current basic block and invalid the cache if so.
* */
auto tc = TestCode["VMTest-SelfModifyingCode2"];
auto code = tc.code;
if (code.empty()) {
return;
}
auto start = (QBDI::rword)code.data();
auto stop = (QBDI::rword)(code.data() + code.size());
QBDI::simulateCall(state, FAKE_RET_ADDR);
vm.addInstrumentedRange(start, stop);
QBDI::RangeSet<QBDI::rword> instrumentedRange{};
QBDI::Range<QBDI::rword> currentSeq{0, 0};
// set the current sequence
vm.addVMEventCB(QBDI::VMEvent::SEQUENCE_ENTRY,
[&instrumentedRange, ¤tSeq](
QBDI::VMInstanceRef vm, const QBDI::VMState *vmState,
QBDI::GPRState *, QBDI::FPRState *) {
currentSeq = {vmState->sequenceStart, vmState->sequenceEnd};
instrumentedRange.add(currentSeq);
return QBDI::VMAction::CONTINUE;
});
// Detect self modifing code in already cached code
vm.addMemAccessCB(
QBDI::MemoryAccessType::MEMORY_WRITE,
[&instrumentedRange, ¤tSeq](QBDI::VMInstanceRef vm,
QBDI::GPRState *, QBDI::FPRState *) {
for (const auto &acc : vm->getInstMemoryAccess()) {
if ((acc.type & QBDI::MemoryAccessType::MEMORY_WRITE) == 0) {
continue;
}
if ((acc.flags & QBDI::MemoryAccessFlags::MEMORY_UNKNOWN_SIZE) != 0) {
continue;
}
if (instrumentedRange.overlaps(
{acc.accessAddress, acc.accessAddress + acc.size})) {
// the access override a code address, clear the cache
vm->clearCache(acc.accessAddress, acc.accessAddress + acc.size);
// if the access is in the current sequence, schedule
// the clear now
if (currentSeq.overlaps(
{acc.accessAddress, acc.accessAddress + acc.size})) {
return QBDI::VMAction::BREAK_TO_VM;
}
}
}
return QBDI::VMAction::CONTINUE;
});
bool ran = vm.run(start, FAKE_RET_ADDR);
REQUIRE(ran);
QBDI::rword ret = QBDI_GPR_GET(state, QBDI::REG_RETURN);
REQUIRE(ret == (QBDI::rword)42);
SUCCEED();
}
| 54,803 | 22,984 |
//******************************************************************************
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
//******************************************************************************
//
// ProfilePictureControl.xaml.cpp
// Implementation of the ProfilePictureControl class
//
#include "pch.h"
#include "FacebookProfilePictureControl.xaml.h"
#include "FBSingleValue.h"
#include <string>
using namespace concurrency;
using namespace winsdkfb;
using namespace winsdkfb::Graph;
using namespace Platform;
using namespace Windows::ApplicationModel::Core;
using namespace Windows::Foundation;
using namespace Windows::Foundation::Collections;
using namespace Windows::Storage;
using namespace Windows::Storage::Streams;
using namespace Windows::UI::Core;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;
using namespace Windows::UI::Xaml::Controls::Primitives;
using namespace Windows::UI::Xaml::Data;
using namespace Windows::UI::Xaml::Input;
using namespace Windows::UI::Xaml::Media;
using namespace Windows::UI::Xaml::Navigation;
using namespace Windows::UI::Xaml::Media::Imaging;
using namespace Windows::UI::Xaml::Interop;
// At least enough characters to hold a string representation of 32-bit int,
// in decimal. Used for width and height of profile picture.
#define INT_STRING_LENGTH 16
#define ProfilePictureSillhouetteImage \
"ms-appx:///winsdkfb/Images/fb_blank_profile_portrait.png"
DependencyProperty^ ProfilePictureControl::_userIdProperty = DependencyProperty::Register(
L"UserId",
TypeName(String::typeid),
TypeName(ProfilePictureControl::typeid),
ref new PropertyMetadata(
nullptr,
ref new PropertyChangedCallback(&ProfilePictureControl::UserIdPropertyChanged)));
ProfilePictureControl::ProfilePictureControl() :
_CropMode(CroppingType::Square)
{
InitializeComponent();
Update();
}
void ProfilePictureControl::UserIdPropertyChanged(DependencyObject^ d, DependencyPropertyChangedEventArgs^ e)
{
ProfilePictureControl^ instance = static_cast<ProfilePictureControl^>(d);
instance->UserId = static_cast<String^>(e->NewValue);
}
String^ ProfilePictureControl::UserId::get()
{
return safe_cast<String^>(GetValue(_userIdProperty));
}
void ProfilePictureControl::UserId::set(String^ value)
{
SetValue(_userIdProperty, value);
Update();
}
CroppingType ProfilePictureControl::CropMode::get()
{
return _CropMode;
}
void ProfilePictureControl::CropMode::set(CroppingType value)
{
if (_CropMode != value)
{
_CropMode = value;
Update();
}
}
void ProfilePictureControl::SetImageSourceFromUserId()
{
int height = -1;
// specify height == width for square. If user wants original aspect ratio,
// only specify width, and FB graph API will scale and preserve ratio.
if (CropMode == CroppingType::Square)
{
height = (int)this->Width;
}
create_task(GetProfilePictureInfo((int)this->Width, height))
.then([=](FBResult^ result)
{
FBProfilePicture^ info = nullptr;
if (result && (result->Succeeded))
{
info = static_cast<FBProfilePicture^>(result->Object);
}
return info;
})
.then([=](FBProfilePicture^ info)
{
Windows::UI::Core::CoreWindow^ wnd =
CoreApplication::MainView->CoreWindow;
if (wnd)
{
wnd->Dispatcher->RunAsync(CoreDispatcherPriority::Low,
ref new DispatchedHandler([info, this]()
{
if (info)
{
ProfilePic->Stretch = Stretch::Uniform;
ProfilePic->Source = ref new BitmapImage(ref new Uri(info->Url));
}
}));
}
});
}
void ProfilePictureControl::SetImageSourceFromResource()
{
Windows::UI::Core::CoreWindow^ wnd =
CoreApplication::MainView->CoreWindow;
if (wnd)
{
wnd->Dispatcher->RunAsync(CoreDispatcherPriority::Low,
ref new DispatchedHandler([=]()
{
Uri^ u = ref new Uri(ProfilePictureSillhouetteImage);
ProfilePic->Stretch = Stretch::Uniform;
ProfilePic->Source = ref new BitmapImage(u);
}));
}
}
void ProfilePictureControl::Update()
{
if (UserId)
{
SetImageSourceFromUserId();
}
else
{
SetImageSourceFromResource();
}
}
task<FBResult^>
ProfilePictureControl::GetProfilePictureInfo(
int width,
int height
)
{
PropertySet^ parameters = ref new PropertySet();
wchar_t whBuffer[INT_STRING_LENGTH];
task<FBResult^> result;
parameters->Insert(L"redirect", L"false");
if (width > -1)
{
if (!_itow_s(width, whBuffer, INT_STRING_LENGTH, 10))
{
String^ Value = ref new String(whBuffer);
parameters->Insert(L"width", Value);
}
}
if (height > -1)
{
if (!_itow_s(height, whBuffer, INT_STRING_LENGTH, 10))
{
String^ Value = ref new String(whBuffer);
parameters->Insert(L"height", Value);
}
}
if (UserId)
{
String^ path = UserId + L"/picture";
FBSingleValue^ value = ref new FBSingleValue(
path,
parameters,
ref new FBJsonClassFactory([](String^ JsonText) -> Object^
{
return FBProfilePicture::FromJson(JsonText);
}));
result = create_task(value->GetAsync());
}
return result;
}
| 6,110 | 1,809 |
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2006-01-16
// Updated : 2008-10-07
// Licence : This source is under MIT License
// File : glm/gtx/vector_access.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename valType>
GLM_FUNC_QUALIFIER void set
(
detail::tvec2<valType>& v,
valType const & x,
valType const & y
)
{
v.x = x;
v.y = y;
}
template <typename valType>
GLM_FUNC_QUALIFIER void set
(
detail::tvec3<valType>& v,
valType const & x,
valType const & y,
valType const & z
)
{
v.x = x;
v.y = y;
v.z = z;
}
template <typename valType>
GLM_FUNC_QUALIFIER void set
(
detail::tvec4<valType>& v,
valType const & x,
valType const & y,
valType const & z,
valType const & w
)
{
v.x = x;
v.y = y;
v.z = z;
v.w = w;
}
}//namespace glm
| 1,196 | 480 |
#include <gtest/gtest.h>
#include <exception>
#include <memory>
#include "util/pop_test_fixture.hpp"
#include "veriblock/blockchain/pop/fork_resolution.hpp"
using namespace altintegration;
struct VbkBlockTreeTestFixture : public ::testing::Test {
MockMiner popminer;
void endorseVBK(size_t height) {
auto* endorsedIndex = popminer.vbk().getBestChain()[(int32_t)height];
ASSERT_TRUE(endorsedIndex);
auto btctx = popminer.createBtcTxEndorsingVbkBlock(*endorsedIndex->header);
auto btccontaining = popminer.mineBtcBlocks(1);
auto vbkpoptx = popminer.createVbkPopTxEndorsingVbkBlock(
*btccontaining->header,
btctx,
*endorsedIndex->header,
popminer.getBtcParams().getGenesisBlock().getHash());
popminer.mineVbkBlocks(1);
}
VbkPopTx generatePopTx(const VbkBlock& endorsedBlock) {
auto Btctx = popminer.createBtcTxEndorsingVbkBlock(endorsedBlock);
auto* btcBlockTip = popminer.mineBtcBlocks(1);
return popminer.createVbkPopTxEndorsingVbkBlock(
*btcBlockTip->header,
Btctx,
endorsedBlock,
popminer.getBtcParams().getGenesisBlock().getHash());
}
};
TEST_F(VbkBlockTreeTestFixture, FilterChainForForkResolution) {
using namespace internal;
size_t numVbkBlocks = 200ull;
ASSERT_EQ(popminer.vbk().getComparator().getIndex(),
popminer.vbk().getBestChain().tip());
popminer.mineVbkBlocks(numVbkBlocks);
auto& best = popminer.vbk().getBestChain();
ASSERT_EQ(best.blocksCount(), numVbkBlocks + 1);
endorseVBK(176);
endorseVBK(166);
endorseVBK(169);
endorseVBK(143);
endorseVBK(143);
endorseVBK(87);
endorseVBK(87);
endorseVBK(91);
endorseVBK(91);
ASSERT_EQ(best.blocksCount(), numVbkBlocks + 10);
popminer.mineVbkBlocks(1);
ASSERT_EQ(best.blocksCount(), numVbkBlocks + 11);
auto protoContext =
getProtoKeystoneContext(best, popminer.btc(), popminer.getVbkParams());
EXPECT_EQ(protoContext.size(),
numVbkBlocks / popminer.getVbkParams().getKeystoneInterval());
EXPECT_EQ(protoContext[0].blockHeight, 20);
EXPECT_EQ(protoContext[0].referencedByBlocks.size(), 0);
EXPECT_EQ(protoContext[1].blockHeight, 40);
EXPECT_EQ(protoContext[1].referencedByBlocks.size(), 0);
EXPECT_EQ(protoContext[2].blockHeight, 60);
EXPECT_EQ(protoContext[2].referencedByBlocks.size(), 0);
EXPECT_EQ(protoContext[3].blockHeight, 80);
EXPECT_EQ(protoContext[3].referencedByBlocks.size(), 4);
EXPECT_EQ(protoContext[4].blockHeight, 100);
EXPECT_EQ(protoContext[4].referencedByBlocks.size(), 0);
EXPECT_EQ(protoContext[5].blockHeight, 120);
EXPECT_EQ(protoContext[5].referencedByBlocks.size(), 0);
EXPECT_EQ(protoContext[6].blockHeight, 140);
EXPECT_EQ(protoContext[6].referencedByBlocks.size(), 2);
EXPECT_EQ(protoContext[7].blockHeight, 160);
EXPECT_EQ(protoContext[7].referencedByBlocks.size(), 3);
auto keystoneContext = getKeystoneContext(protoContext, popminer.btc());
EXPECT_EQ(keystoneContext.size(),
numVbkBlocks / popminer.getVbkParams().getKeystoneInterval());
auto max = std::numeric_limits<int32_t>::max();
EXPECT_EQ(keystoneContext[0].blockHeight, 20);
EXPECT_EQ(keystoneContext[0].firstBlockPublicationHeight, max);
EXPECT_EQ(keystoneContext[1].blockHeight, 40);
EXPECT_EQ(keystoneContext[1].firstBlockPublicationHeight, max);
EXPECT_EQ(keystoneContext[2].blockHeight, 60);
EXPECT_EQ(keystoneContext[2].firstBlockPublicationHeight, max);
EXPECT_EQ(keystoneContext[3].blockHeight, 80);
EXPECT_EQ(keystoneContext[3].firstBlockPublicationHeight, 6);
EXPECT_EQ(keystoneContext[4].blockHeight, 100);
EXPECT_EQ(keystoneContext[4].firstBlockPublicationHeight, max);
EXPECT_EQ(keystoneContext[5].blockHeight, 120);
EXPECT_EQ(keystoneContext[5].firstBlockPublicationHeight, max);
EXPECT_EQ(keystoneContext[6].blockHeight, 140);
EXPECT_EQ(keystoneContext[6].firstBlockPublicationHeight, 4);
EXPECT_EQ(keystoneContext[7].blockHeight, 160);
EXPECT_EQ(keystoneContext[7].firstBlockPublicationHeight, 1);
}
TEST_F(VbkBlockTreeTestFixture, addAllPayloads_failure_test) {
// start with 30 BTC blocks
auto* btcBlockTip = popminer.mineBtcBlocks(30);
ASSERT_EQ(btcBlockTip->getHash(),
popminer.btc().getBestChain().tip()->getHash());
// start with 65 VBK blocks
auto* vbkBlockTip = popminer.mineVbkBlocks(65);
ASSERT_EQ(popminer.vbk().getBestChain().tip()->getHash(),
vbkBlockTip->getHash());
// Make 5 endorsements valid endorsements
auto* endorsedVbkBlock1 = vbkBlockTip->getAncestor(vbkBlockTip->height - 11);
ASSERT_EQ(endorsedVbkBlock1->endorsedBy.size(), 0);
auto* endorsedVbkBlock2 = vbkBlockTip->getAncestor(vbkBlockTip->height - 12);
ASSERT_EQ(endorsedVbkBlock2->endorsedBy.size(), 0);
auto* endorsedVbkBlock3 = vbkBlockTip->getAncestor(vbkBlockTip->height - 13);
ASSERT_EQ(endorsedVbkBlock3->endorsedBy.size(), 0);
auto* endorsedVbkBlock4 = vbkBlockTip->getAncestor(vbkBlockTip->height - 14);
ASSERT_EQ(endorsedVbkBlock4->endorsedBy.size(), 0);
auto* endorsedVbkBlock5 = vbkBlockTip->getAncestor(vbkBlockTip->height - 15);
ASSERT_EQ(endorsedVbkBlock5->endorsedBy.size(), 0);
generatePopTx(*endorsedVbkBlock1->header);
generatePopTx(*endorsedVbkBlock2->header);
generatePopTx(*endorsedVbkBlock3->header);
generatePopTx(*endorsedVbkBlock4->header);
generatePopTx(*endorsedVbkBlock5->header);
ASSERT_EQ(popminer.vbkmempool.size(), 5);
vbkBlockTip = popminer.mineVbkBlocks(1);
ASSERT_EQ(popminer.vbk().getBestChain().tip()->getHash(),
vbkBlockTip->getHash());
// check that we have endorsements to the VbBlocks
ASSERT_EQ(endorsedVbkBlock1->endorsedBy.size(), 1);
ASSERT_EQ(endorsedVbkBlock2->endorsedBy.size(), 1);
ASSERT_EQ(endorsedVbkBlock3->endorsedBy.size(), 1);
ASSERT_EQ(endorsedVbkBlock4->endorsedBy.size(), 1);
ASSERT_EQ(endorsedVbkBlock5->endorsedBy.size(), 1);
// mine 40 Vbk blocks
vbkBlockTip = popminer.mineVbkBlocks(40);
ASSERT_EQ(popminer.vbk().getBestChain().tip()->getHash(),
vbkBlockTip->getHash());
// Make 5 endorsements valid endorsements
endorsedVbkBlock1 = vbkBlockTip->getAncestor(vbkBlockTip->height - 11);
ASSERT_EQ(endorsedVbkBlock1->endorsedBy.size(), 0);
endorsedVbkBlock2 = vbkBlockTip->getAncestor(vbkBlockTip->height - 12);
ASSERT_EQ(endorsedVbkBlock2->endorsedBy.size(), 0);
endorsedVbkBlock3 = vbkBlockTip->getAncestor(vbkBlockTip->height - 13);
ASSERT_EQ(endorsedVbkBlock3->endorsedBy.size(), 0);
endorsedVbkBlock4 = vbkBlockTip->getAncestor(vbkBlockTip->height - 14);
ASSERT_EQ(endorsedVbkBlock4->endorsedBy.size(), 0);
endorsedVbkBlock5 = vbkBlockTip->getAncestor(vbkBlockTip->height - 15);
ASSERT_EQ(endorsedVbkBlock5->endorsedBy.size(), 0);
generatePopTx(*endorsedVbkBlock1->header);
generatePopTx(*endorsedVbkBlock2->header);
generatePopTx(*endorsedVbkBlock3->header);
generatePopTx(*endorsedVbkBlock4->header);
generatePopTx(*endorsedVbkBlock5->header);
ASSERT_EQ(popminer.vbkmempool.size(), 5);
// corrupt one of the endorsement
std::vector<uint8_t> new_hash = {1, 2, 3};
popminer.vbkmempool[0].blockOfProof.previousBlock = uint256(new_hash);
EXPECT_THROW(popminer.mineVbkBlocks(1), std::domain_error);
// check that all endorsement have not been applied
ASSERT_EQ(endorsedVbkBlock1->endorsedBy.size(), 0);
ASSERT_EQ(endorsedVbkBlock2->endorsedBy.size(), 0);
ASSERT_EQ(endorsedVbkBlock3->endorsedBy.size(), 0);
ASSERT_EQ(endorsedVbkBlock4->endorsedBy.size(), 0);
ASSERT_EQ(endorsedVbkBlock5->endorsedBy.size(), 0);
}
| 7,577 | 3,224 |
#include "pooling.hpp"
namespace Shadow {
namespace Vision {
template <>
void Pooling2D<DeviceType::kCPU, float>(const float* in_data,
const VecInt& in_shape, int pool_type,
int kernel_size_h, int kernel_size_w,
int stride_h, int stride_w, int pad_h,
int pad_w, const VecInt& out_shape,
float* out_data, Context* context) {
int batch = in_shape[0], channel = in_shape[1];
int in_h = in_shape[2], in_w = in_shape[3];
int out_h = out_shape[2], out_w = out_shape[3];
for (int b = 0; b < batch; ++b) {
for (int c = 0; c < channel; ++c, in_data += in_h * in_w) {
for (int h = 0; h < out_h; ++h) {
for (int w = 0; w < out_w; ++w) {
int hstart = h * stride_h - pad_h;
int wstart = w * stride_w - pad_w;
int hend = std::min(hstart + kernel_size_h, in_h + pad_h);
int wend = std::min(wstart + kernel_size_w, in_w + pad_w);
int pool_size = (hend - hstart) * (wend - wstart);
hstart = std::max(hstart, 0), wstart = std::max(wstart, 0);
hend = std::min(hend, in_h), wend = std::min(wend, in_w);
auto max_val = std::numeric_limits<float>::lowest(), sum_val = 0.f;
for (int ph = hstart; ph < hend; ++ph) {
for (int pw = wstart; pw < wend; ++pw) {
auto value = in_data[ph * in_w + pw];
max_val = std::max(max_val, value);
sum_val += value;
}
}
*out_data++ = (pool_type == 0) ? max_val : sum_val / pool_size;
}
}
}
}
}
template <>
void Pooling3D<DeviceType::kCPU, float>(
const float* in_data, const VecInt& in_shape, int pool_type,
int kernel_size_d, int kernel_size_h, int kernel_size_w, int stride_d,
int stride_h, int stride_w, int pad_d, int pad_h, int pad_w,
const VecInt& out_shape, float* out_data, Context* context) {
int batch = in_shape[0], channel = in_shape[1];
int in_d = in_shape[2], in_h = in_shape[3], in_w = in_shape[4];
int out_d = out_shape[2], out_h = out_shape[3], out_w = out_shape[4];
for (int b = 0; b < batch; ++b) {
for (int c = 0; c < channel; ++c, in_data += in_d * in_h * in_w) {
for (int d = 0; d < out_d; ++d) {
for (int h = 0; h < out_h; ++h) {
for (int w = 0; w < out_w; ++w) {
int dstart = d * stride_d - pad_d;
int hstart = h * stride_h - pad_h;
int wstart = w * stride_w - pad_w;
int dend = std::min(dstart + kernel_size_d, in_d + pad_d);
int hend = std::min(hstart + kernel_size_h, in_h + pad_h);
int wend = std::min(wstart + kernel_size_w, in_w + pad_w);
int pool_size = (dend - dstart) * (hend - hstart) * (wend - wstart);
dstart = std::max(dstart, 0), hstart = std::max(hstart, 0),
wstart = std::max(wstart, 0);
dend = std::min(dend, in_d), hend = std::min(hend, in_h),
wend = std::min(wend, in_w);
auto max_val = std::numeric_limits<float>::lowest(), sum_val = 0.f;
for (int pd = dstart; pd < dend; ++pd) {
for (int ph = hstart; ph < hend; ++ph) {
for (int pw = wstart; pw < wend; ++pw) {
auto value = in_data[(pd * in_h + ph) * in_w + pw];
max_val = std::max(max_val, value);
sum_val += value;
}
}
}
*out_data++ = (pool_type == 0) ? max_val : sum_val / pool_size;
}
}
}
}
}
}
} // namespace Vision
} // namespace Shadow
namespace Shadow {
REGISTER_OP_KERNEL_DEFAULT(PoolingCPU, PoolingKernelDefault<DeviceType::kCPU>);
#if defined(USE_DNNL)
class PoolingKernelDNNL : public PoolingKernel {
public:
PoolingKernelDNNL() {
default_kernel_ =
std::make_shared<PoolingKernelDefault<DeviceType::kCPU>>();
}
void Run(const std::shared_ptr<Blob>& input, std::shared_ptr<Blob>& output,
Workspace* ws, int pool_type, int kernel_size_h, int kernel_size_w,
int stride_h, int stride_w, int pad_h, int pad_w,
bool full_pooling) override {
if (full_pooling) {
default_kernel_->Run(input, output, ws, pool_type, kernel_size_h,
kernel_size_w, stride_h, stride_w, pad_h, pad_w,
full_pooling);
} else {
const auto& src_desc = idnnl::create_memory_desc<float>(
input->shape(), dnnl::memory::format_tag::nchw);
const auto& dst_desc = idnnl::create_memory_desc<float>(
output->shape(), dnnl::memory::format_tag::nchw);
idnnl::common_forward<dnnl::pooling_forward>(
ws->Ctx()->dnnl_handle(),
dnnl::pooling_forward::desc(
dnnl::prop_kind::forward_inference, get_algorithm(pool_type),
src_desc, dst_desc, {stride_h, stride_w},
{kernel_size_h, kernel_size_w}, {pad_h, pad_w}, {pad_h, pad_w}),
input->data<float>(), output->mutable_data<float>());
}
}
void Run(const std::shared_ptr<Blob>& input, std::shared_ptr<Blob>& output,
Workspace* ws, int pool_type, int kernel_size_d, int kernel_size_h,
int kernel_size_w, int stride_d, int stride_h, int stride_w,
int pad_d, int pad_h, int pad_w, bool full_pooling) override {
if (full_pooling) {
default_kernel_->Run(input, output, ws, pool_type, kernel_size_d,
kernel_size_h, kernel_size_w, stride_d, stride_h,
stride_w, pad_d, pad_h, pad_w, full_pooling);
} else {
const auto& src_desc = idnnl::create_memory_desc<float>(
input->shape(), dnnl::memory::format_tag::ncdhw);
const auto& dst_desc = idnnl::create_memory_desc<float>(
output->shape(), dnnl::memory::format_tag::ncdhw);
idnnl::common_forward<dnnl::pooling_forward>(
ws->Ctx()->dnnl_handle(),
dnnl::pooling_forward::desc(
dnnl::prop_kind::forward_inference, get_algorithm(pool_type),
src_desc, dst_desc, {stride_d, stride_h, stride_w},
{kernel_size_d, kernel_size_h, kernel_size_w},
{pad_d, pad_h, pad_w}, {pad_d, pad_h, pad_w}),
input->data<float>(), output->mutable_data<float>());
}
}
DeviceType device_type() const override { return DeviceType::kCPU; }
std::string kernel_type() const override { return "DNNL"; }
private:
static dnnl::algorithm get_algorithm(int pool_type) {
switch (pool_type) {
case 0:
return dnnl::algorithm::pooling_max;
case 1:
return dnnl::algorithm::pooling_avg_include_padding;
default:
return dnnl::algorithm::undef;
}
}
std::shared_ptr<PoolingKernelDefault<DeviceType::kCPU>> default_kernel_ =
nullptr;
};
REGISTER_OP_KERNEL_DNNL(PoolingCPU, PoolingKernelDNNL);
#endif
} // namespace Shadow
| 7,084 | 2,558 |
/* NAME:
TRange.cpp
DESCRIPTION:
NRange tests.
COPYRIGHT:
Copyright (c) 2006-2021, refNum Software
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
___________________________________________________________________________
*/
//=============================================================================
// Includes
//-----------------------------------------------------------------------------
// Nano
#include "NFormat.h"
#include "NRange.h"
#include "NTestFixture.h"
//=============================================================================
// Internal Constants
//-----------------------------------------------------------------------------
static const NRange kTestRange1{0, 5};
static const NRange kTestRange2{3, 7};
static const NRange kTestRange3{3, 4};
//=============================================================================
// Fixture
//-----------------------------------------------------------------------------
NANO_FIXTURE(TRange)
{
NRange theRange;
};
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "Default")
{
// Perform the test
REQUIRE(theRange.GetLocation() == 0);
REQUIRE(theRange.GetSize() == 0);
REQUIRE(kNRangeNone.GetLocation() == kNNotFound);
REQUIRE(kNRangeNone.GetSize() == 0);
REQUIRE(kNRangeAll.GetLocation() == 0);
REQUIRE(kNRangeAll.GetSize() == kNNotFound);
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "Intersects")
{
// Perform the test
REQUIRE(NRange(4, 3).Intersects(NRange(6, 2))); // 456 ~ 67 = true (after)
REQUIRE(!NRange(4, 3).Intersects(NRange(8, 2))); // 456 ~ 89 = false (after gap)
REQUIRE(NRange(4, 3).Intersects(NRange(3, 2))); // 456 ~ 34 = true (before)
REQUIRE(!NRange(4, 3).Intersects(NRange(1, 2))); // 456 ~ 12 = false (before gap)
REQUIRE(!NRange(4, 3).Intersects(NRange(0, 0))); // 456 ~ . = false (empty)
REQUIRE(!NRange(4, 3).Intersects(NRange(3, 0))); // 456 ~ . = false (empty)
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "Contains")
{
// Perform the test
REQUIRE(!NRange(4, 3).Contains(3)); // 456 ~ 3 = false (before)
REQUIRE(NRange(4, 3).Contains(4)); // 456 ~ 4 = true (first)
REQUIRE(NRange(4, 3).Contains(5)); // 456 ~ 5 = true (inside)
REQUIRE(NRange(4, 3).Contains(6)); // 456 ~ 6 = true (last)
REQUIRE(!NRange(4, 3).Contains(7)); // 456 ~ 7 = false (after)
REQUIRE(!NRange(4, 0).Contains(3)); // . ~ 3 = false (never)
REQUIRE(!NRange(4, 0).Contains(4)); // . ~ 4 = false (never)
REQUIRE(!NRange(4, 0).Contains(5)); // . ~ 5 = false (never)
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "IsMeta")
{
// Perform the test
REQUIRE(!kTestRange1.IsMeta());
REQUIRE(!kTestRange2.IsMeta());
REQUIRE(kNRangeNone.IsMeta());
REQUIRE(kNRangeAll.IsMeta());
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "IsEmpty")
{
// Perform the test
REQUIRE(kNRangeNone.IsEmpty());
REQUIRE(!NRange(4, 3).IsEmpty());
REQUIRE(NRange(4, 0).IsEmpty());
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "GetLocation")
{
// Perform the test
theRange = kTestRange1;
REQUIRE(theRange.GetLocation() == kTestRange1.GetLocation());
theRange.SetLocation(theRange.GetLocation() + 1);
REQUIRE(theRange.GetLocation() != kTestRange1.GetLocation());
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "AddOffset")
{
// Perform the test
theRange.SetRange(0, 3);
theRange.AddOffset(0);
REQUIRE(theRange == NRange(0, 3));
theRange.SetRange(0, 3);
theRange.AddOffset(1);
REQUIRE(theRange == NRange(1, 3));
theRange.SetRange(0, 3);
theRange.AddOffset(2);
REQUIRE(theRange == NRange(2, 3));
theRange.SetRange(1, 3);
theRange.AddOffset(0);
REQUIRE(theRange == NRange(1, 3));
theRange.SetRange(2, 3);
theRange.AddOffset(1);
REQUIRE(theRange == NRange(3, 3));
theRange.SetRange(3, 3);
theRange.AddOffset(2);
REQUIRE(theRange == NRange(5, 3));
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "GetSize")
{
// Perform the test
theRange = kTestRange1;
REQUIRE(theRange.GetSize() == kTestRange1.GetSize());
theRange.SetSize(theRange.GetSize() + 1);
REQUIRE(theRange.GetSize() != kTestRange1.GetSize());
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "Contents")
{
// Perform the test
REQUIRE(kTestRange1.GetLocation() == 0);
REQUIRE(kTestRange1.GetSize() == 5);
REQUIRE(kTestRange1.GetPosition(0) == kTestRange1.GetFirst());
REQUIRE(kTestRange1.GetPosition(1) == kTestRange1.GetFirst() + 1);
REQUIRE(kTestRange1.GetPosition(2) == kTestRange1.GetFirst() + 2);
REQUIRE(kTestRange1.GetFirst() == 0);
REQUIRE(kTestRange1.GetLast() == 4);
REQUIRE(kTestRange1.GetNext() == 5);
// Perform the test
REQUIRE(kTestRange2.GetLocation() == 3);
REQUIRE(kTestRange2.GetSize() == 7);
REQUIRE(kTestRange2.GetPosition(0) == kTestRange2.GetFirst());
REQUIRE(kTestRange2.GetPosition(1) == kTestRange2.GetFirst() + 1);
REQUIRE(kTestRange2.GetPosition(2) == kTestRange2.GetFirst() + 2);
REQUIRE(kTestRange2.GetFirst() == 3);
REQUIRE(kTestRange2.GetLast() == 9);
REQUIRE(kTestRange2.GetNext() == 10);
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "GetOffset")
{
// Perform the test
REQUIRE(NRange(0, 3).GetOffset(0) == NRange(0, 3));
REQUIRE(NRange(0, 3).GetOffset(1) == NRange(1, 3));
REQUIRE(NRange(0, 3).GetOffset(2) == NRange(2, 3));
REQUIRE(NRange(1, 3).GetOffset(0) == NRange(1, 3));
REQUIRE(NRange(2, 3).GetOffset(1) == NRange(3, 3));
REQUIRE(NRange(3, 3).GetOffset(2) == NRange(5, 3));
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "GetUnion")
{
// Perform the test
REQUIRE(NRange(4, 3).GetUnion(NRange(6, 2)) == NRange(4, 4)); // 456 + 67 = 4567 (after)
REQUIRE(NRange(4, 3).GetUnion(NRange(8, 2)) ==
NRange(4, 6)); // 456 + 89 = 456789 (after gap)
REQUIRE(NRange(4, 3).GetUnion(NRange(3, 2)) == NRange(3, 4)); // 456 + 34 = 3456 (before)
REQUIRE(NRange(4, 3).GetUnion(NRange(1, 2)) ==
NRange(1, 6)); // 456 + 12 = 123456 (before gap)
REQUIRE(NRange(4, 3).GetUnion(NRange(0, 0)) == NRange(4, 3)); // 456 + . = 456 (empty)
REQUIRE(NRange(4, 3).GetUnion(NRange(3, 0)) == NRange(4, 3)); // 456 + . = 456 (empty)
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "GetIntersection")
{
// Perform the test
REQUIRE(NRange(4, 3).GetIntersection(NRange(6, 2)) ==
NRange(6, 1)); // 456 ~ 67 = 6 (end)
REQUIRE(NRange(4, 3).GetIntersection(NRange(8, 2)) ==
NRange(0, 0)); // 456 ~ 89 = . (after)
REQUIRE(NRange(4, 3).GetIntersection(NRange(3, 2)) ==
NRange(4, 1)); // 456 ~ 34 = 4 (start)
REQUIRE(NRange(4, 3).GetIntersection(NRange(1, 2)) ==
NRange(0, 0)); // 456 ~ 12 = . (before)
REQUIRE(NRange(4, 3).GetIntersection(NRange(5, 1)) ==
NRange(5, 1)); // 456 ~ 5 = 5 (inside)
REQUIRE(NRange(4, 3).GetIntersection(NRange(3, 5)) ==
NRange(4, 3)); // 456 ~ 34567 = 456 (within)
REQUIRE(NRange(4, 3).GetIntersection(NRange(1, 0)) ==
NRange(0, 0)); // 456 ~ . = . (empty)
REQUIRE(NRange(0, 0).GetIntersection(NRange(1, 2)) ==
NRange(0, 0)); // . ~ 12 = . (empty)
REQUIRE(NRange(4, 0).GetIntersection(NRange(1, 0)) ==
NRange(0, 0)); // . ~ . = . (empty)
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "GetNormalized")
{
// Perform the test
theRange = kNRangeNone.GetNormalized(10);
REQUIRE((theRange.GetLocation() == 0 && theRange.GetSize() == 0)); // Meta (none)
theRange = kNRangeAll.GetNormalized(10);
REQUIRE((theRange.GetLocation() == 0 && theRange.GetSize() == 10)); // Meta (all)
theRange = NRange(3, 7).GetNormalized(10);
REQUIRE(
(theRange.GetLocation() == 3 && theRange.GetSize() == 7)); // Within (non-zero length)
theRange = NRange(3, 9).GetNormalized(10);
REQUIRE((theRange.GetLocation() == 3 && theRange.GetSize() == 7)); // Within (clamped length)
theRange = NRange(3, 0).GetNormalized(10);
REQUIRE((theRange.GetLocation() == 3 && theRange.GetSize() == 0)); // Within (zero length)
theRange = NRange(30, 7).GetNormalized(10);
REQUIRE(
(theRange.GetLocation() == 30 && theRange.GetSize() == 0)); // Outside (non-zero length)
theRange = NRange(30, 0).GetNormalized(0);
REQUIRE((theRange.GetLocation() == 30 && theRange.GetSize() == 0)); // Outside (zero length)
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "CompareEqual")
{
// Perform the test
REQUIRE(kTestRange1 == kTestRange1);
REQUIRE(kTestRange1 != kTestRange2);
REQUIRE(kNRangeNone == kNRangeNone);
REQUIRE(kNRangeNone != kNRangeAll);
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "CompareOrder")
{
// Perform the test
REQUIRE(kTestRange1 <= kTestRange1);
REQUIRE(kTestRange1 < kTestRange2);
REQUIRE(kTestRange1 < kTestRange3);
REQUIRE(kTestRange2 > kTestRange1);
REQUIRE(kTestRange2 >= kTestRange2);
REQUIRE(kTestRange2 > kTestRange3);
REQUIRE(kTestRange3 > kTestRange1);
REQUIRE(kTestRange3 < kTestRange2);
REQUIRE(kTestRange3 >= kTestRange3);
}
//=============================================================================
// Test Case
//-----------------------------------------------------------------------------
NANO_TEST(TRange, "Format")
{
// Perform the test
REQUIRE(NFormat("{}", kTestRange1) == "{location = 0, size = 5}");
REQUIRE(NFormat("{}", kTestRange2) == "{location = 3, size = 7}");
REQUIRE(NFormat("{}", kTestRange3) == "{location = 3, size = 4}");
}
| 13,059 | 4,925 |
/*
* tuning.cpp
* ----------
* Purpose: Alternative sample tuning.
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "tuning.h"
#include "../common/mptIO.h"
#include "../common/serialization_utils.h"
#include "../common/misc_util.h"
#include <string>
#include <cmath>
OPENMPT_NAMESPACE_BEGIN
namespace Tuning {
namespace CTuningS11n
{
void ReadStr(std::istream &iStrm, mpt::ustring &ustr, const std::size_t dummy, mpt::Charset charset);
void ReadNoteMap(std::istream &iStrm, std::map<NOTEINDEXTYPE, mpt::ustring> &m, const std::size_t dummy, mpt::Charset charset);
void ReadRatioTable(std::istream& iStrm, std::vector<RATIOTYPE>& v, const size_t);
void WriteNoteMap(std::ostream &oStrm, const std::map<NOTEINDEXTYPE, mpt::ustring> &m);
void WriteStr(std::ostream &oStrm, const mpt::ustring &ustr);
struct RatioWriter
{
RatioWriter(uint16 nWriteCount = s_nDefaultWriteCount) : m_nWriteCount(nWriteCount) {}
void operator()(std::ostream& oStrm, const std::vector<float>& v);
uint16 m_nWriteCount;
enum : uint16 { s_nDefaultWriteCount = (uint16_max >> 2) };
};
}
using namespace CTuningS11n;
/*
Version history:
4->5: Lots of changes, finestep interpretation revamp, fileformat revamp.
3->4: Changed sizetypes in serialisation from size_t(uint32) to
smaller types (uint8, USTEPTYPE) (March 2007)
*/
/*
Version changes:
3->4: Finetune related internal structure and serialization revamp.
2->3: The type for the size_type in the serialisation changed
from default(size_t, uint32) to unsigned STEPTYPE. (March 2007)
*/
static_assert(CTuning::s_RatioTableFineSizeMaxDefault < static_cast<USTEPINDEXTYPE>(FINESTEPCOUNT_MAX));
CTuning::CTuning()
: m_TuningType(Type::GENERAL)
, m_FineStepCount(0)
{
m_RatioTable.clear();
m_NoteMin = s_NoteMinDefault;
m_RatioTable.resize(s_RatioTableSizeDefault, 1);
m_GroupSize = 0;
m_GroupRatio = 0;
m_RatioTableFine.clear();
}
bool CTuning::CreateGroupGeometric(const NOTEINDEXTYPE &s, const RATIOTYPE &r, const NOTEINDEXTYPE &startindex)
{
if(s < 1 || !IsValidRatio(r) || startindex < GetNoteRange().first)
{
return false;
}
std::vector<RATIOTYPE> v;
v.reserve(s);
for(NOTEINDEXTYPE i = startindex; i < startindex + s; i++)
{
v.push_back(GetRatio(i));
}
return CreateGroupGeometric(v, r, GetNoteRange(), startindex);
}
bool CTuning::CreateGroupGeometric(const std::vector<RATIOTYPE> &v, const RATIOTYPE &r, const NoteRange &range, const NOTEINDEXTYPE &ratiostartpos)
{
if(range.first > range.last || v.size() == 0)
{
return false;
}
if(ratiostartpos < range.first || range.last < ratiostartpos || static_cast<UNOTEINDEXTYPE>(range.last - ratiostartpos) < static_cast<UNOTEINDEXTYPE>(v.size() - 1))
{
return false;
}
if(GetFineStepCount() > FINESTEPCOUNT_MAX)
{
return false;
}
for(size_t i = 0; i < v.size(); i++)
{
if(v[i] < 0)
{
return false;
}
}
if(r <= 0)
{
return false;
}
m_TuningType = Type::GROUPGEOMETRIC;
m_NoteMin = range.first;
m_GroupSize = mpt::saturate_cast<NOTEINDEXTYPE>(v.size());
m_GroupRatio = std::fabs(r);
m_RatioTable.resize(range.last - range.first + 1);
std::copy(v.begin(), v.end(), m_RatioTable.begin() + (ratiostartpos - range.first));
for(int32 i = ratiostartpos - 1; i >= m_NoteMin && ratiostartpos > NOTEINDEXTYPE_MIN; i--)
{
m_RatioTable[i - m_NoteMin] = m_RatioTable[i - m_NoteMin + m_GroupSize] / m_GroupRatio;
}
for(int32 i = ratiostartpos + m_GroupSize; i <= range.last && ratiostartpos <= (NOTEINDEXTYPE_MAX - m_GroupSize); i++)
{
m_RatioTable[i - m_NoteMin] = m_GroupRatio * m_RatioTable[i - m_NoteMin - m_GroupSize];
}
UpdateFineStepTable();
return true;
}
bool CTuning::CreateGeometric(const UNOTEINDEXTYPE &p, const RATIOTYPE &r)
{
return CreateGeometric(p, r, GetNoteRange());
}
bool CTuning::CreateGeometric(const UNOTEINDEXTYPE &s, const RATIOTYPE &r, const NoteRange &range)
{
if(range.first > range.last)
{
return false;
}
if(s < 1 || !IsValidRatio(r))
{
return false;
}
if(range.last - range.first + 1 > NOTEINDEXTYPE_MAX)
{
return false;
}
m_TuningType = Type::GEOMETRIC;
m_RatioTable.clear();
m_NoteMin = s_NoteMinDefault;
m_RatioTable.resize(s_RatioTableSizeDefault, static_cast<RATIOTYPE>(1.0));
m_GroupSize = 0;
m_GroupRatio = 0;
m_RatioTableFine.clear();
m_NoteMin = range.first;
m_GroupSize = mpt::saturate_cast<NOTEINDEXTYPE>(s);
m_GroupRatio = std::fabs(r);
const RATIOTYPE stepRatio = std::pow(m_GroupRatio, static_cast<RATIOTYPE>(1.0) / static_cast<RATIOTYPE>(m_GroupSize));
m_RatioTable.resize(range.last - range.first + 1);
for(int32 i = range.first; i <= range.last; i++)
{
m_RatioTable[i - m_NoteMin] = std::pow(stepRatio, static_cast<RATIOTYPE>(i));
}
UpdateFineStepTable();
return true;
}
mpt::ustring CTuning::GetNoteName(const NOTEINDEXTYPE &x, bool addOctave) const
{
if(!IsValidNote(x))
{
return mpt::ustring();
}
if(GetGroupSize() < 1)
{
const auto i = m_NoteNameMap.find(x);
if(i != m_NoteNameMap.end())
return i->second;
else
return mpt::ufmt::val(x);
}
else
{
const NOTEINDEXTYPE pos = static_cast<NOTEINDEXTYPE>(mpt::wrapping_modulo(x, m_GroupSize));
const NOTEINDEXTYPE middlePeriodNumber = 5;
mpt::ustring rValue;
const auto nmi = m_NoteNameMap.find(pos);
if(nmi != m_NoteNameMap.end())
{
rValue = nmi->second;
if(addOctave)
{
rValue += mpt::ufmt::val(middlePeriodNumber + mpt::wrapping_divide(x, m_GroupSize));
}
}
else
{
//By default, using notation nnP for notes; nn <-> note character starting
//from 'A' with char ':' as fill char, and P is period integer. For example:
//C:5, D:3, R:7
if(m_GroupSize <= 26)
{
rValue = mpt::ToUnicode(mpt::Charset::UTF8, std::string(1, static_cast<char>(pos + 'A')));
rValue += UL_(":");
} else
{
rValue = mpt::ufmt::HEX0<1>(pos % 16) + mpt::ufmt::HEX0<1>((pos / 16) % 16);
if(pos > 0xff)
{
rValue = mpt::ToUnicode(mpt::Charset::UTF8, mpt::ToLowerCaseAscii(mpt::ToCharset(mpt::Charset::UTF8, rValue)));
}
}
if(addOctave)
{
rValue += mpt::ufmt::val(middlePeriodNumber + mpt::wrapping_divide(x, m_GroupSize));
}
}
return rValue;
}
}
void CTuning::SetNoteName(const NOTEINDEXTYPE &n, const mpt::ustring &str)
{
const NOTEINDEXTYPE pos = (GetGroupSize() < 1) ? n : static_cast<NOTEINDEXTYPE>(mpt::wrapping_modulo(n, m_GroupSize));
if(!str.empty())
{
m_NoteNameMap[pos] = str;
} else
{
const auto iter = m_NoteNameMap.find(pos);
if(iter != m_NoteNameMap.end())
{
m_NoteNameMap.erase(iter);
}
}
}
// Without finetune
RATIOTYPE CTuning::GetRatio(const NOTEINDEXTYPE note) const
{
if(!IsValidNote(note))
{
return s_DefaultFallbackRatio;
}
return m_RatioTable[note - m_NoteMin];
}
// With finetune
RATIOTYPE CTuning::GetRatio(const NOTEINDEXTYPE baseNote, const STEPINDEXTYPE baseFineSteps) const
{
const STEPINDEXTYPE fineStepCount = static_cast<STEPINDEXTYPE>(GetFineStepCount());
if(fineStepCount == 0 || baseFineSteps == 0)
{
return GetRatio(static_cast<NOTEINDEXTYPE>(baseNote + baseFineSteps));
}
// If baseFineSteps is more than the number of finesteps between notes, note is increased.
// So first figuring out what note and fineStep values to actually use.
// Interpreting finestep==-1 on note x so that it is the same as finestep==fineStepCount on note x-1.
// Note: If fineStepCount is n, n+1 steps are needed to get to next note.
const NOTEINDEXTYPE note = static_cast<NOTEINDEXTYPE>(baseNote + mpt::wrapping_divide(baseFineSteps, (fineStepCount + 1)));
const STEPINDEXTYPE fineStep = mpt::wrapping_modulo(baseFineSteps, (fineStepCount + 1));
if(!IsValidNote(note))
{
return s_DefaultFallbackRatio;
}
if(fineStep == 0)
{
return m_RatioTable[note - m_NoteMin];
}
RATIOTYPE fineRatio = static_cast<RATIOTYPE>(1.0);
if(GetType() == Type::GEOMETRIC && m_RatioTableFine.size() > 0)
{
fineRatio = m_RatioTableFine[fineStep - 1];
} else if(GetType() == Type::GROUPGEOMETRIC && m_RatioTableFine.size() > 0)
{
fineRatio = m_RatioTableFine[GetRefNote(note) * fineStepCount + fineStep - 1];
} else
{
// Geometric finestepping
fineRatio = std::pow(GetRatio(note + 1) / GetRatio(note), static_cast<RATIOTYPE>(fineStep) / (fineStepCount + 1));
}
return m_RatioTable[note - m_NoteMin] * fineRatio;
}
bool CTuning::SetRatio(const NOTEINDEXTYPE& s, const RATIOTYPE& r)
{
if(GetType() != Type::GROUPGEOMETRIC && GetType() != Type::GENERAL)
{
return false;
}
//Creating ratio table if doesn't exist.
if(m_RatioTable.empty())
{
m_RatioTable.assign(s_RatioTableSizeDefault, 1);
m_NoteMin = s_NoteMinDefault;
}
if(!IsValidNote(s))
{
return false;
}
m_RatioTable[s - m_NoteMin] = std::fabs(r);
if(GetType() == Type::GROUPGEOMETRIC)
{ // update other groups
for(NOTEINDEXTYPE n = m_NoteMin; n < m_NoteMin + static_cast<NOTEINDEXTYPE>(m_RatioTable.size()); ++n)
{
if(n == s)
{
// nothing
} else if(std::abs(n - s) % m_GroupSize == 0)
{
m_RatioTable[n - m_NoteMin] = std::pow(m_GroupRatio, static_cast<RATIOTYPE>(n - s) / static_cast<RATIOTYPE>(m_GroupSize)) * m_RatioTable[s - m_NoteMin];
}
}
UpdateFineStepTable();
}
return true;
}
void CTuning::SetFineStepCount(const USTEPINDEXTYPE& fs)
{
m_FineStepCount = std::clamp(mpt::saturate_cast<STEPINDEXTYPE>(fs), STEPINDEXTYPE(0), FINESTEPCOUNT_MAX);
UpdateFineStepTable();
}
void CTuning::UpdateFineStepTable()
{
if(m_FineStepCount <= 0)
{
m_RatioTableFine.clear();
return;
}
if(GetType() == Type::GEOMETRIC)
{
if(m_FineStepCount > s_RatioTableFineSizeMaxDefault)
{
m_RatioTableFine.clear();
return;
}
m_RatioTableFine.resize(m_FineStepCount);
const RATIOTYPE q = GetRatio(GetNoteRange().first + 1) / GetRatio(GetNoteRange().first);
const RATIOTYPE rFineStep = std::pow(q, static_cast<RATIOTYPE>(1)/(m_FineStepCount+1));
for(USTEPINDEXTYPE i = 1; i<=m_FineStepCount; i++)
m_RatioTableFine[i-1] = std::pow(rFineStep, static_cast<RATIOTYPE>(i));
return;
}
if(GetType() == Type::GROUPGEOMETRIC)
{
const UNOTEINDEXTYPE p = GetGroupSize();
if(p > s_RatioTableFineSizeMaxDefault / m_FineStepCount)
{
//In case fineratiotable would become too large, not using
//table for it.
m_RatioTableFine.clear();
return;
}
else
{
//Creating 'geometric' finestepping between notes.
m_RatioTableFine.resize(p * m_FineStepCount);
const NOTEINDEXTYPE startnote = GetRefNote(GetNoteRange().first);
for(UNOTEINDEXTYPE i = 0; i<p; i++)
{
const NOTEINDEXTYPE refnote = GetRefNote(startnote+i);
const RATIOTYPE rFineStep = std::pow(GetRatio(refnote+1) / GetRatio(refnote), static_cast<RATIOTYPE>(1)/(m_FineStepCount+1));
for(UNOTEINDEXTYPE j = 1; j<=m_FineStepCount; j++)
{
m_RatioTableFine[m_FineStepCount * refnote + (j-1)] = std::pow(rFineStep, static_cast<RATIOTYPE>(j));
}
}
return;
}
}
if(GetType() == Type::GENERAL)
{
//Not using table with tuning of type general.
m_RatioTableFine.clear();
return;
}
//Should not reach here.
m_RatioTableFine.clear();
m_FineStepCount = 0;
}
bool CTuning::Multiply(const RATIOTYPE r)
{
if(!IsValidRatio(r))
{
return false;
}
for(auto & ratio : m_RatioTable)
{
ratio *= r;
}
return true;
}
bool CTuning::ChangeGroupsize(const NOTEINDEXTYPE& s)
{
if(s < 1)
return false;
if(m_TuningType == Type::GROUPGEOMETRIC)
return CreateGroupGeometric(s, GetGroupRatio(), 0);
if(m_TuningType == Type::GEOMETRIC)
return CreateGeometric(s, GetGroupRatio());
return false;
}
bool CTuning::ChangeGroupRatio(const RATIOTYPE& r)
{
if(!IsValidRatio(r))
return false;
if(m_TuningType == Type::GROUPGEOMETRIC)
return CreateGroupGeometric(GetGroupSize(), r, 0);
if(m_TuningType == Type::GEOMETRIC)
return CreateGeometric(GetGroupSize(), r);
return false;
}
SerializationResult CTuning::InitDeserialize(std::istream &iStrm, mpt::Charset defaultCharset)
{
// Note: OpenMPT since at least r323 writes version number (4<<24)+4 while it
// reads version number (5<<24)+4 or earlier.
// We keep this behaviour.
if(iStrm.fail())
return SerializationResult::Failure;
srlztn::SsbRead ssb(iStrm);
ssb.BeginRead("CTB244RTI", (5 << 24) + 4); // version
int8 use_utf8 = 0;
ssb.ReadItem(use_utf8, "UTF8");
const mpt::Charset charset = use_utf8 ? mpt::Charset::UTF8 : defaultCharset;
ssb.ReadItem(m_TuningName, "0", [charset](std::istream &iStrm, mpt::ustring &ustr, const std::size_t dummy){ return ReadStr(iStrm, ustr, dummy, charset); });
uint16 dummyEditMask = 0xffff;
ssb.ReadItem(dummyEditMask, "1");
std::underlying_type<Type>::type type = 0;
ssb.ReadItem(type, "2");
m_TuningType = static_cast<Type>(type);
ssb.ReadItem(m_NoteNameMap, "3", [charset](std::istream &iStrm, std::map<NOTEINDEXTYPE, mpt::ustring> &m, const std::size_t dummy){ return ReadNoteMap(iStrm, m, dummy, charset); });
ssb.ReadItem(m_FineStepCount, "4");
// RTI entries.
ssb.ReadItem(m_RatioTable, "RTI0", ReadRatioTable);
ssb.ReadItem(m_NoteMin, "RTI1");
ssb.ReadItem(m_GroupSize, "RTI2");
ssb.ReadItem(m_GroupRatio, "RTI3");
UNOTEINDEXTYPE ratiotableSize = 0;
ssb.ReadItem(ratiotableSize, "RTI4");
// If reader status is ok and m_NoteMin is somewhat reasonable, process data.
if(!((ssb.GetStatus() & srlztn::SNT_FAILURE) == 0 && m_NoteMin >= -300 && m_NoteMin <= 300))
{
return SerializationResult::Failure;
}
// reject unknown types
if(m_TuningType != Type::GENERAL && m_TuningType != Type::GROUPGEOMETRIC && m_TuningType != Type::GEOMETRIC)
{
return SerializationResult::Failure;
}
if(m_GroupSize < 0)
{
return SerializationResult::Failure;
}
m_FineStepCount = std::clamp(mpt::saturate_cast<STEPINDEXTYPE>(m_FineStepCount), STEPINDEXTYPE(0), FINESTEPCOUNT_MAX);
if(m_RatioTable.size() > static_cast<size_t>(NOTEINDEXTYPE_MAX))
{
return SerializationResult::Failure;
}
if((GetType() == Type::GROUPGEOMETRIC) || (GetType() == Type::GEOMETRIC))
{
if(ratiotableSize < 1 || ratiotableSize > NOTEINDEXTYPE_MAX)
{
return SerializationResult::Failure;
}
if(GetType() == Type::GEOMETRIC)
{
if(!CreateGeometric(GetGroupSize(), GetGroupRatio(), NoteRange{m_NoteMin, static_cast<NOTEINDEXTYPE>(m_NoteMin + ratiotableSize - 1)}))
{
return SerializationResult::Failure;
}
} else
{
if(!CreateGroupGeometric(m_RatioTable, GetGroupRatio(), NoteRange{m_NoteMin, static_cast<NOTEINDEXTYPE>(m_NoteMin + ratiotableSize - 1)}, m_NoteMin))
{
return SerializationResult::Failure;
}
}
} else
{
UpdateFineStepTable();
}
return SerializationResult::Success;
}
template<class T, class SIZETYPE, class Tdst>
static bool VectorFromBinaryStream(std::istream& inStrm, std::vector<Tdst>& v, const SIZETYPE maxSize = (std::numeric_limits<SIZETYPE>::max)())
{
if(!inStrm.good())
return false;
SIZETYPE size = 0;
mpt::IO::ReadIntLE<SIZETYPE>(inStrm, size);
if(size > maxSize)
return false;
v.resize(size);
for(std::size_t i = 0; i<size; i++)
{
T tmp = T();
mpt::IO::Read(inStrm, tmp);
v[i] = tmp;
}
return inStrm.good();
}
SerializationResult CTuning::InitDeserializeOLD(std::istream &inStrm, mpt::Charset defaultCharset)
{
if(!inStrm.good())
return SerializationResult::Failure;
const std::streamoff startPos = inStrm.tellg();
//First checking is there expected begin sequence.
char begin[8];
MemsetZero(begin);
inStrm.read(begin, sizeof(begin));
if(std::memcmp(begin, "CTRTI_B.", 8))
{
//Returning stream position if beginmarker was not found.
inStrm.seekg(startPos);
return SerializationResult::Failure;
}
//Version
int16 version = 0;
mpt::IO::ReadIntLE<int16>(inStrm, version);
if(version != 2 && version != 3)
return SerializationResult::Failure;
char begin2[8];
MemsetZero(begin2);
inStrm.read(begin2, sizeof(begin2));
if(std::memcmp(begin2, "CT<sfs>B", 8))
{
return SerializationResult::Failure;
}
int16 version2 = 0;
mpt::IO::ReadIntLE<int16>(inStrm, version2);
if(version2 != 3 && version2 != 4)
{
return SerializationResult::Failure;
}
//Tuning name
if(version2 <= 3)
{
std::string tmpName;
if(!mpt::IO::ReadSizedStringLE<uint32>(inStrm, tmpName, 0xffff))
{
return SerializationResult::Failure;
}
m_TuningName = mpt::ToUnicode(defaultCharset, tmpName);
} else
{
std::string tmpName;
if(!mpt::IO::ReadSizedStringLE<uint8>(inStrm, tmpName))
{
return SerializationResult::Failure;
}
m_TuningName = mpt::ToUnicode(defaultCharset, tmpName);
}
//Const mask
int16 em = 0;
mpt::IO::ReadIntLE<int16>(inStrm, em);
//Tuning type
int16 tt = 0;
mpt::IO::ReadIntLE<int16>(inStrm, tt);
m_TuningType = static_cast<Type>(tt);
//Notemap
uint16 size = 0;
if(version2 <= 3)
{
uint32 tempsize = 0;
mpt::IO::ReadIntLE<uint32>(inStrm, tempsize);
if(tempsize > 0xffff)
{
return SerializationResult::Failure;
}
size = mpt::saturate_cast<uint16>(tempsize);
} else
{
mpt::IO::ReadIntLE<uint16>(inStrm, size);
}
for(UNOTEINDEXTYPE i = 0; i<size; i++)
{
std::string str;
int16 n = 0;
mpt::IO::ReadIntLE<int16>(inStrm, n);
if(version2 <= 3)
{
if(!mpt::IO::ReadSizedStringLE<uint32>(inStrm, str, 0xffff))
{
return SerializationResult::Failure;
}
} else
{
if(!mpt::IO::ReadSizedStringLE<uint8>(inStrm, str))
{
return SerializationResult::Failure;
}
}
m_NoteNameMap[n] = mpt::ToUnicode(defaultCharset, str);
}
//End marker
char end2[8];
MemsetZero(end2);
inStrm.read(end2, sizeof(end2));
if(std::memcmp(end2, "CT<sfs>E", 8))
{
return SerializationResult::Failure;
}
// reject unknown types
if(m_TuningType != Type::GENERAL && m_TuningType != Type::GROUPGEOMETRIC && m_TuningType != Type::GEOMETRIC)
{
return SerializationResult::Failure;
}
//Ratiotable
if(version <= 2)
{
if(!VectorFromBinaryStream<IEEE754binary32LE, uint32>(inStrm, m_RatioTable, 0xffff))
{
return SerializationResult::Failure;
}
} else
{
if(!VectorFromBinaryStream<IEEE754binary32LE, uint16>(inStrm, m_RatioTable))
{
return SerializationResult::Failure;
}
}
//Fineratios
if(version <= 2)
{
if(!VectorFromBinaryStream<IEEE754binary32LE, uint32>(inStrm, m_RatioTableFine, 0xffff))
{
return SerializationResult::Failure;
}
} else
{
if(!VectorFromBinaryStream<IEEE754binary32LE, uint16>(inStrm, m_RatioTableFine))
{
return SerializationResult::Failure;
}
}
m_FineStepCount = mpt::saturate_cast<USTEPINDEXTYPE>(m_RatioTableFine.size());
// m_NoteMin
int16 notemin = 0;
mpt::IO::ReadIntLE<int16>(inStrm, notemin);
m_NoteMin = notemin;
if(m_NoteMin < -200 || m_NoteMin > 200)
{
return SerializationResult::Failure;
}
//m_GroupSize
int16 groupsize = 0;
mpt::IO::ReadIntLE<int16>(inStrm, groupsize);
m_GroupSize = groupsize;
if(m_GroupSize < 0)
{
return SerializationResult::Failure;
}
//m_GroupRatio
IEEE754binary32LE groupratio = IEEE754binary32LE(0.0f);
mpt::IO::Read(inStrm, groupratio);
m_GroupRatio = groupratio;
if(m_GroupRatio < 0)
{
return SerializationResult::Failure;
}
char end[8];
MemsetZero(end);
inStrm.read(reinterpret_cast<char*>(&end), sizeof(end));
if(std::memcmp(end, "CTRTI_E.", 8))
{
return SerializationResult::Failure;
}
// reject corrupt tunings
if(m_RatioTable.size() > static_cast<std::size_t>(NOTEINDEXTYPE_MAX))
{
return SerializationResult::Failure;
}
if((m_GroupSize <= 0 || m_GroupRatio <= 0) && m_TuningType != Type::GENERAL)
{
return SerializationResult::Failure;
}
if(m_TuningType == Type::GROUPGEOMETRIC || m_TuningType == Type::GEOMETRIC)
{
if(m_RatioTable.size() < static_cast<std::size_t>(m_GroupSize))
{
return SerializationResult::Failure;
}
}
// convert old finestepcount
if(m_FineStepCount > 0)
{
m_FineStepCount -= 1;
}
m_FineStepCount = std::clamp(mpt::saturate_cast<STEPINDEXTYPE>(m_FineStepCount), STEPINDEXTYPE(0), FINESTEPCOUNT_MAX);
UpdateFineStepTable();
if(m_TuningType == Type::GEOMETRIC)
{
// Convert old geometric to new groupgeometric because old geometric tunings
// can have ratio(0) != 1.0, which would get lost when saving nowadays.
if(mpt::saturate_cast<NOTEINDEXTYPE>(m_RatioTable.size()) >= m_GroupSize - m_NoteMin)
{
std::vector<RATIOTYPE> ratios;
for(NOTEINDEXTYPE n = 0; n < m_GroupSize; ++n)
{
ratios.push_back(m_RatioTable[n - m_NoteMin]);
}
CreateGroupGeometric(ratios, m_GroupRatio, GetNoteRange(), 0);
}
}
return SerializationResult::Success;
}
Tuning::SerializationResult CTuning::Serialize(std::ostream& outStrm) const
{
// Note: OpenMPT since at least r323 writes version number (4<<24)+4 while it
// reads version number (5<<24)+4.
// We keep this behaviour.
srlztn::SsbWrite ssb(outStrm);
ssb.BeginWrite("CTB244RTI", (4 << 24) + 4); // version
ssb.WriteItem(int8(1), "UTF8");
if (m_TuningName.length() > 0)
ssb.WriteItem(m_TuningName, "0", WriteStr);
uint16 dummyEditMask = 0xffff;
ssb.WriteItem(dummyEditMask, "1");
ssb.WriteItem(static_cast<std::underlying_type<Type>::type>(m_TuningType), "2");
if (m_NoteNameMap.size() > 0)
ssb.WriteItem(m_NoteNameMap, "3", WriteNoteMap);
if (GetFineStepCount() > 0)
ssb.WriteItem(m_FineStepCount, "4");
const Tuning::Type tt = GetType();
if (GetGroupRatio() > 0)
ssb.WriteItem(m_GroupRatio, "RTI3");
if (tt == Type::GROUPGEOMETRIC)
ssb.WriteItem(m_RatioTable, "RTI0", RatioWriter(GetGroupSize()));
if (tt == Type::GENERAL)
ssb.WriteItem(m_RatioTable, "RTI0", RatioWriter());
if (tt == Type::GEOMETRIC)
ssb.WriteItem(m_GroupSize, "RTI2");
if(tt == Type::GEOMETRIC || tt == Type::GROUPGEOMETRIC)
{ //For Groupgeometric this data is the number of ratios in ratiotable.
UNOTEINDEXTYPE ratiotableSize = static_cast<UNOTEINDEXTYPE>(m_RatioTable.size());
ssb.WriteItem(ratiotableSize, "RTI4");
}
// m_NoteMin
ssb.WriteItem(m_NoteMin, "RTI1");
ssb.FinishWrite();
return ((ssb.GetStatus() & srlztn::SNT_FAILURE) != 0) ? Tuning::SerializationResult::Failure : Tuning::SerializationResult::Success;
}
#ifdef MODPLUG_TRACKER
bool CTuning::WriteSCL(std::ostream &f, const mpt::PathString &filename) const
{
mpt::IO::WriteTextCRLF(f, MPT_FORMAT("! {}")(mpt::ToCharset(mpt::Charset::ISO8859_1, (filename.GetFileName() + filename.GetFileExt()).ToUnicode())));
mpt::IO::WriteTextCRLF(f, "!");
std::string name = mpt::ToCharset(mpt::Charset::ISO8859_1, GetName());
for(auto & c : name) { if(static_cast<uint8>(c) < 32) c = ' '; } // remove control characters
if(name.length() >= 1 && name[0] == '!') name[0] = '?'; // do not confuse description with comment
mpt::IO::WriteTextCRLF(f, name);
if(GetType() == Type::GEOMETRIC)
{
mpt::IO::WriteTextCRLF(f, MPT_FORMAT(" {}")(m_GroupSize));
mpt::IO::WriteTextCRLF(f, "!");
for(NOTEINDEXTYPE n = 0; n < m_GroupSize; ++n)
{
double ratio = std::pow(static_cast<double>(m_GroupRatio), static_cast<double>(n + 1) / static_cast<double>(m_GroupSize));
double cents = std::log2(ratio) * 1200.0;
mpt::IO::WriteTextCRLF(f, MPT_FORMAT(" {} ! {}")(
mpt::fmt::fix(cents),
mpt::ToCharset(mpt::Charset::ISO8859_1, GetNoteName((n + 1) % m_GroupSize, false))
));
}
} else if(GetType() == Type::GROUPGEOMETRIC)
{
mpt::IO::WriteTextCRLF(f, MPT_FORMAT(" {}")(m_GroupSize));
mpt::IO::WriteTextCRLF(f, "!");
for(NOTEINDEXTYPE n = 0; n < m_GroupSize; ++n)
{
bool last = (n == (m_GroupSize - 1));
double baseratio = static_cast<double>(GetRatio(0));
double ratio = static_cast<double>(last ? m_GroupRatio : GetRatio(n + 1)) / baseratio;
double cents = std::log2(ratio) * 1200.0;
mpt::IO::WriteTextCRLF(f, MPT_FORMAT(" {} ! {}")(
mpt::fmt::fix(cents),
mpt::ToCharset(mpt::Charset::ISO8859_1, GetNoteName((n + 1) % m_GroupSize, false))
));
}
} else if(GetType() == Type::GENERAL)
{
mpt::IO::WriteTextCRLF(f, MPT_FORMAT(" {}")(m_RatioTable.size() + 1));
mpt::IO::WriteTextCRLF(f, "!");
double baseratio = 1.0;
for(NOTEINDEXTYPE n = 0; n < mpt::saturate_cast<NOTEINDEXTYPE>(m_RatioTable.size()); ++n)
{
baseratio = std::min(baseratio, static_cast<double>(m_RatioTable[n]));
}
for(NOTEINDEXTYPE n = 0; n < mpt::saturate_cast<NOTEINDEXTYPE>(m_RatioTable.size()); ++n)
{
double ratio = static_cast<double>(m_RatioTable[n]) / baseratio;
double cents = std::log2(ratio) * 1200.0;
mpt::IO::WriteTextCRLF(f, MPT_FORMAT(" {} ! {}")(
mpt::fmt::fix(cents),
mpt::ToCharset(mpt::Charset::ISO8859_1, GetNoteName(n + m_NoteMin, false))
));
}
mpt::IO::WriteTextCRLF(f, MPT_FORMAT(" {} ! {}")(
mpt::fmt::val(1),
std::string()
));
} else
{
return false;
}
return true;
}
#endif
namespace CTuningS11n
{
void RatioWriter::operator()(std::ostream& oStrm, const std::vector<float>& v)
{
const std::size_t nWriteCount = std::min(v.size(), static_cast<std::size_t>(m_nWriteCount));
mpt::IO::WriteAdaptiveInt64LE(oStrm, nWriteCount);
for(size_t i = 0; i < nWriteCount; i++)
mpt::IO::Write(oStrm, IEEE754binary32LE(v[i]));
}
void ReadNoteMap(std::istream &iStrm, std::map<NOTEINDEXTYPE, mpt::ustring> &m, const std::size_t dummy, mpt::Charset charset)
{
MPT_UNREFERENCED_PARAMETER(dummy);
uint64 val;
mpt::IO::ReadAdaptiveInt64LE(iStrm, val);
LimitMax(val, 256u); // Read 256 at max.
for(size_t i = 0; i < val; i++)
{
int16 key;
mpt::IO::ReadIntLE<int16>(iStrm, key);
std::string str;
mpt::IO::ReadSizedStringLE<uint8>(iStrm, str);
m[key] = mpt::ToUnicode(charset, str);
}
}
void ReadRatioTable(std::istream& iStrm, std::vector<RATIOTYPE>& v, const size_t)
{
uint64 val;
mpt::IO::ReadAdaptiveInt64LE(iStrm, val);
v.resize(std::min(mpt::saturate_cast<std::size_t>(val), std::size_t(256))); // Read 256 vals at max.
for(size_t i = 0; i < v.size(); i++)
{
IEEE754binary32LE tmp(0.0f);
mpt::IO::Read(iStrm, tmp);
v[i] = tmp;
}
}
void ReadStr(std::istream &iStrm, mpt::ustring &ustr, const std::size_t dummy, mpt::Charset charset)
{
MPT_UNREFERENCED_PARAMETER(dummy);
std::string str;
uint64 val;
mpt::IO::ReadAdaptiveInt64LE(iStrm, val);
size_t nSize = (val > 255) ? 255 : static_cast<size_t>(val); // Read 255 characters at max.
str.clear();
str.resize(nSize);
for(size_t i = 0; i < nSize; i++)
mpt::IO::ReadIntLE(iStrm, str[i]);
if(str.find_first_of('\0') != std::string::npos)
{ // trim \0 at the end
str.resize(str.find_first_of('\0'));
}
ustr = mpt::ToUnicode(charset, str);
}
void WriteNoteMap(std::ostream &oStrm, const std::map<NOTEINDEXTYPE, mpt::ustring> &m)
{
mpt::IO::WriteAdaptiveInt64LE(oStrm, m.size());
for(auto &mi : m)
{
mpt::IO::WriteIntLE<int16>(oStrm, mi.first);
mpt::IO::WriteSizedStringLE<uint8>(oStrm, mpt::ToCharset(mpt::Charset::UTF8, mi.second));
}
}
void WriteStr(std::ostream &oStrm, const mpt::ustring &ustr)
{
std::string str = mpt::ToCharset(mpt::Charset::UTF8, ustr);
mpt::IO::WriteAdaptiveInt64LE(oStrm, str.size());
oStrm.write(str.c_str(), str.size());
}
} // namespace CTuningS11n.
} // namespace Tuning
OPENMPT_NAMESPACE_END
| 27,033 | 11,885 |
/*
* Copyright (C) 2019 MediaTek Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "MtkCam/DebugExifUtils"
#include <map>
#include <vector>
//
#include <mtkcam/custom/ExifFactory.h>
//
#include <mtkcam/utils/std/Log.h>
#include <mtkcam/utils/metadata/IMetadata.h>
#include <mtkcam/utils/exif/DebugExifUtils.h>
//
using NSCam::DebugExifUtils;
using NSCam::IMetadata;
using NSCam::MPoint;
using NSCam::MPointF;
using NSCam::MRect;
using NSCam::MRectF;
using NSCam::MSize;
using NSCam::MSizeF;
using NSCam::Type2Type;
/******************************************************************************
*
******************************************************************************/
static auto getDebugExif() {
static auto const inst = MAKE_DebugExif();
return inst;
}
static auto getBufInfo_cam() {
static auto const inst =
((NULL != getDebugExif())
? getDebugExif()->getBufInfo(DEBUG_EXIF_KEYID_CAM)
: NULL);
return inst;
}
// ---------------------------------------------------------------------------
template <typename T>
static inline MVOID updateEntry(IMetadata* metadata,
const MUINT32 tag,
const T& val) {
if (metadata == NULL) {
CAM_LOGW("pMetadata is NULL");
return;
}
IMetadata::IEntry entry(tag);
entry.push_back(val, Type2Type<T>());
metadata->update(tag, entry);
}
template <class T>
static MBOOL tryGetMetaData(IMetadata* pMetadata, MUINT32 const tag, T* rVal) {
if (pMetadata == NULL) {
return MFALSE;
}
IMetadata::IEntry entry = pMetadata->entryFor(tag);
if (!entry.isEmpty()) {
*rVal = entry.itemAt(0, Type2Type<T>());
return MTRUE;
}
return MFALSE;
}
static bool setDebugExifMF(const MUINT32 tagKey,
const MUINT32 tagData,
const std::map<MUINT32, MUINT32>& debugInfoList,
IMetadata* exifMetadata) {
auto it = getBufInfo_cam()->body_layout.find(DEBUG_EXIF_MID_CAM_MF);
if (it == getBufInfo_cam()->body_layout.end()) {
CAM_LOGE("cannot find the layout: DEBUG_EXIF_MID_CAM_MF");
return false;
}
auto const& info = it->second;
// allocate memory of debug information
IMetadata::Memory debugInfoSet;
debugInfoSet.resize(info.size);
// add debug information
{
auto const tagId_MF_TAG_VERSION = getDebugExif()->getTagId_MF_TAG_VERSION();
auto pTag = reinterpret_cast<debug_exif_field*>(debugInfoSet.editArray());
pTag[tagId_MF_TAG_VERSION].u4FieldID = (0x1000000 | tagId_MF_TAG_VERSION);
pTag[tagId_MF_TAG_VERSION].u4FieldValue = info.version;
for (const auto& item : debugInfoList) {
const MUINT32 index = item.first;
pTag[index].u4FieldID = (0x1000000 | index);
pTag[index].u4FieldValue = item.second;
}
}
// update debug exif metadata
updateEntry<MINT32>(exifMetadata, tagKey, DEBUG_EXIF_MID_CAM_MF);
updateEntry<IMetadata::Memory>(exifMetadata, tagData, debugInfoSet);
return true;
}
static bool setDebugExifRESERVE3(const MUINT32 tagKey,
const MUINT32 tagData,
const MUINT32 size,
const void* debugInfoList,
IMetadata* exifMetadata) {
auto it =
getBufInfo_cam()->body_layout.find(DEBUG_EXIF_MID_CAM_RESERVE3); // MDP
if (it == getBufInfo_cam()->body_layout.end()) {
CAM_LOGE("cannot find the layout: DEBUG_EXIF_MID_CAM_RESERVE3");
return false;
}
auto const& info = it->second;
// allocate memory of debug information
IMetadata::Memory debugInfoValue;
debugInfoValue.resize(info.size);
// add debug information
{
auto pTag = reinterpret_cast<MUINT32*>(debugInfoValue.editArray());
::memcpy(pTag, debugInfoList, size);
}
// update debug exif metadata
updateEntry<MINT32>(exifMetadata, tagKey, DEBUG_EXIF_MID_CAM_RESERVE3);
updateEntry<IMetadata::Memory>(exifMetadata, tagData, debugInfoValue);
return true;
}
static bool setDebugExifCAM(const MUINT32 tagKey,
const MUINT32 tagData,
const std::map<MUINT32, MUINT32>& debugInfoList,
IMetadata* exifMetadata) {
auto it = getBufInfo_cam()->body_layout.find(DEBUG_EXIF_MID_CAM_CMN);
if (it == getBufInfo_cam()->body_layout.end()) {
CAM_LOGE("cannot find the layout: DEBUG_EXIF_MID_CAM_CMN");
return false;
}
IMetadata::Memory debugInfoSet;
if (!tryGetMetaData(exifMetadata, tagData, &debugInfoSet)) {
// CAM_LOGD("[debug mode] debugInfoList size: %d", debugInfoList.size());
// allocate memory of debug information
auto const& info = it->second;
debugInfoSet.resize(info.size);
}
// allocate memory of debug information
auto pTag = reinterpret_cast<debug_exif_field*>(debugInfoSet.editArray());
for (const auto& item : debugInfoList) {
const MUINT32 index = item.first;
// CAM_LOGD("[debug mode] item: %d value: %d", item.first, item.second);
pTag[index].u4FieldID = (0x1000000 | index);
pTag[index].u4FieldValue = item.second;
}
// update debug exif metadata
updateEntry<MINT32>(exifMetadata, tagKey, DEBUG_EXIF_MID_CAM_CMN);
updateEntry<IMetadata::Memory>(exifMetadata, tagData, debugInfoSet);
return true;
}
// ---------------------------------------------------------------------------
IMetadata* DebugExifUtils::setDebugExif(
const DebugExifType type,
const MUINT32 tagKey,
const MUINT32 tagData,
const std::map<MUINT32, MUINT32>& debugInfoList,
IMetadata* exifMetadata) {
if (exifMetadata == NULL) {
CAM_LOGW("invalid metadata(%p)", exifMetadata);
return nullptr;
}
if (!getDebugExif()) {
CAM_LOGE("bad getDebugExif()");
return nullptr;
}
if (!getBufInfo_cam()) {
CAM_LOGE("bad getBufInfo_cam()");
return nullptr;
}
bool ret = [=, &type, &debugInfoList](IMetadata* metadata) -> bool {
switch (type) {
case DebugExifType::DEBUG_EXIF_MF:
return setDebugExifMF(tagKey, tagData, debugInfoList, metadata);
case DebugExifType::DEBUG_EXIF_CAM:
return setDebugExifCAM(tagKey, tagData, debugInfoList, metadata);
default:
CAM_LOGW("invalid debug exif type, do nothing");
return false;
}
}(exifMetadata);
return ret ? exifMetadata : nullptr;
}
// ---------------------------------------------------------------------------
IMetadata* DebugExifUtils::setDebugExif(const DebugExifType type,
const MUINT32 tagKey,
const MUINT32 tagData,
const MUINT32 size,
const void* debugInfoList,
IMetadata* exifMetadata) {
if (exifMetadata == NULL) {
CAM_LOGW("invalid metadata(%p)", exifMetadata);
return nullptr;
}
if (!getDebugExif()) {
CAM_LOGE("bad getDebugExif()");
return nullptr;
}
if (!getBufInfo_cam()) {
CAM_LOGE("bad getBufInfo_cam()");
return nullptr;
}
bool ret = [=, &type, &debugInfoList](IMetadata* metadata) -> bool {
switch (type) {
case DebugExifType::DEBUG_EXIF_RESERVE3:
return setDebugExifRESERVE3(tagKey, tagData, size, debugInfoList,
metadata);
default:
CAM_LOGW("invalid debug exif type, do nothing");
return false;
}
}(exifMetadata);
return ret ? exifMetadata : nullptr;
}
| 8,088 | 2,680 |
#include "LaunchDarklyHelpers.h"
#include "Dom/JsonObject.h"
#include "Serialization/JsonSerializer.h"
#include "Serialization/JsonWriter.h"
#include "LdNodeObject.h"
#include "LdUserObject.h"
FVector ULaunchDarklyHelpers::LdNodeObjectToVector(ULdNodeObject* LdDataObject)
{
TSharedPtr<FJsonObject> LdData = LdDataObject->GetObjectData();
if(LdData == nullptr)
{
return FVector();
}
FVector V(
LdData->HasTypedField<EJson::Number>("x") ? LdData->GetNumberField("x") : 0.0f,
LdData->HasTypedField<EJson::Number>("y") ? LdData->GetNumberField("y") : 0.0f,
LdData->HasTypedField<EJson::Number>("z") ? LdData->GetNumberField("z") : 0.0f
);
return V;
}
ULdNodeObject* ULaunchDarklyHelpers::VectorToLdNodeObject(FVector V)
{
ULdNodeObject* NodeObject = NewObject<ULdNodeObject>();
TSharedPtr<FJsonObject> Node = MakeShared<FJsonObject>();
Node->SetNumberField("x", V.X);
Node->SetNumberField("y", V.Y);
Node->SetNumberField("z", V.Z);
NodeObject->Initialize(Node);
return NodeObject;
}
FColor ULaunchDarklyHelpers::LdNodeObjectToColor(ULdNodeObject* LdDataObject)
{
TSharedPtr<FJsonObject> LdData = LdDataObject->GetObjectData();
if(LdData == nullptr)
{
return FColor();
}
FColor C(
LdData->HasTypedField<EJson::Number>("r") ? (uint8)LdData->GetNumberField("r") : 0,
LdData->HasTypedField<EJson::Number>("g") ? (uint8)LdData->GetNumberField("g") : 0,
LdData->HasTypedField<EJson::Number>("b") ? (uint8)LdData->GetNumberField("b") : 0,
LdData->HasTypedField<EJson::Number>("a") ? (uint8)LdData->GetNumberField("a") : 0
);
return C;
}
ULdNodeObject* ULaunchDarklyHelpers::ColorToLdNodeObject(FColor C)
{
ULdNodeObject* NodeObject = NewObject<ULdNodeObject>();
TSharedPtr<FJsonObject> Node = MakeShared<FJsonObject>();
Node->SetNumberField("a", C.A);
Node->SetNumberField("r", C.R);
Node->SetNumberField("g", C.G);
Node->SetNumberField("b", C.B);
NodeObject->Initialize(Node);
return NodeObject;
}
FLinearColor ULaunchDarklyHelpers::LdNodeObjectToLinearColor(ULdNodeObject* LdDataObject)
{
TSharedPtr<FJsonObject> LdData = LdDataObject->GetObjectData();
if(LdData == nullptr)
{
return FLinearColor();
}
FLinearColor C(
LdData->HasTypedField<EJson::Number>("r") ? LdData->GetNumberField("r") : 0.0f,
LdData->HasTypedField<EJson::Number>("g") ? LdData->GetNumberField("g") : 0.0f,
LdData->HasTypedField<EJson::Number>("b") ? LdData->GetNumberField("b") : 0.0f,
LdData->HasTypedField<EJson::Number>("a") ? LdData->GetNumberField("a") : 0.0f
);
return C;
}
ULdNodeObject* ULaunchDarklyHelpers::LinearColorToLdNodeObject(FLinearColor LC)
{
ULdNodeObject* NodeObject = NewObject<ULdNodeObject>();
TSharedPtr<FJsonObject> Node = MakeShared<FJsonObject>();
Node->SetNumberField("a", LC.A);
Node->SetNumberField("r", LC.R);
Node->SetNumberField("g", LC.G);
Node->SetNumberField("b", LC.B);
NodeObject->Initialize(Node);
return NodeObject;
}
FString ULaunchDarklyHelpers::LdNodeObjectHashToString(ULdNodeObject* const LdNodeData)
{
return LdNodeData != nullptr ? JsonObjectToString(LdNodeData->GetObjectData()) : FString("NULL NODE");
}
FString ULaunchDarklyHelpers::JsonObjectToString(TSharedPtr<FJsonObject> LdNodeData)
{
if(LdNodeData != nullptr)
{
FString JsonOutput;
TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&JsonOutput);
FJsonSerializer::Serialize(LdNodeData.ToSharedRef(), Writer);
return JsonOutput.IsEmpty() ? FString("{}") : JsonOutput;
}
return FString("{}");
}
TSharedPtr<FJsonObject> ULaunchDarklyHelpers::StringToJsonObject(FString LdNodeData)
{
TSharedPtr<FJsonObject> JsonOutput = MakeShared<FJsonObject>();
if(LdNodeData.IsEmpty() == false)
{
TSharedRef< TJsonReader<> > Writer = TJsonReaderFactory<>::Create(LdNodeData);
FJsonSerializer::Deserialize(Writer, JsonOutput);
}
return JsonOutput;
}
| 3,968 | 1,564 |
//
// MainPage.xaml.cpp
// Implementation of the MainPage class.
//
#include "pch.h"
#include "MainPage.xaml.h"
using namespace DialSketch;
using namespace Platform;
using namespace Windows::Foundation;
using namespace Windows::Foundation::Collections;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;
using namespace Windows::UI::Xaml::Controls::Primitives;
using namespace Windows::UI::Xaml::Data;
using namespace Windows::UI::Xaml::Input;
using namespace Windows::UI::Xaml::Media;
using namespace Windows::UI::Xaml::Navigation;
MainPage::MainPage()
{
InitializeComponent();
Loaded += ref new RoutedEventHandler([this] (Object^ sender, RoutedEventArgs^ args)
{
polyline->Points->Append(Point((float)(drawingGrid->ActualWidth / 2),
(float)(drawingGrid->ActualHeight / 2)));
});
}
void MainPage::OnDialValueChanged(Object^ sender, RangeBaseValueChangedEventArgs^ args)
{
Dial^ dial = dynamic_cast<Dial^>(sender);
RotateTransform^ rotate = dynamic_cast<RotateTransform^>(dial->RenderTransform);
rotate->Angle = args->NewValue;
double xFraction = (horzDial->Value - horzDial->Minimum) / (horzDial->Maximum - horzDial->Minimum);
double yFraction = (vertDial->Value - vertDial->Minimum) / (vertDial->Maximum - vertDial->Minimum);
double x = xFraction * drawingGrid->ActualWidth;
double y = yFraction * drawingGrid->ActualHeight;
polyline->Points->Append(Point((float)x, (float)y));
}
void MainPage::OnClearButtonClick(Object^ sender, RoutedEventArgs^ args)
{
polyline->Points->Clear();
}
| 1,675 | 515 |
/*
* ini.cpp
*
* Created on: Feb 11, 2015
* Author: kristone
*/
#include "sf/archive/ini.h"
#include "sf/exception.h"
#include "common/transcode.h"
#include <iterator>
#include <algorithm>
#include <locale>
namespace casual
{
namespace sf
{
namespace archive
{
namespace ini
{
namespace
{
namespace local
{
const std::string magic{ '@' };
} // local
} //
Load::Load() = default;
Load::~Load() = default;
namespace
{
namespace local
{
std::string trim( std::string string)
{
const auto trimmer = [] ( const std::string::value_type character)
{ return ! std::isspace( character, std::locale::classic()); };
string.erase( string.begin(), std::find_if( string.begin(), string.end(), trimmer));
string.erase( std::find_if( string.rbegin(), string.rend(), trimmer).base(), string.end());
return string;
}
// TODO: Make it streamable
std::string decode( const std::string& data)
{
std::ostringstream stream;
for( std::string::size_type idx = 0; idx < data.size(); ++idx)
{
if( data[idx] == '\\')
{
// TODO: handle all control-characters (and back-slash)
switch( data[++idx])
{
case '\\': stream.put( '\\'); break;
case '0': stream.put( '\0'); break;
case 'a': stream.put( '\a'); break;
case 'b': stream.put( '\b'); break;
case 'f': stream.put( '\f'); break;
case 'n': stream.put( '\n'); break;
case 'r': stream.put( '\r'); break;
case 't': stream.put( '\t'); break;
case 'v': stream.put( '\v'); break;
default: throw exception::archive::invalid::Document{ "Invalid content"};
}
}
else
{
stream.put( data[idx]);
}
}
return stream.str();
}
void parse_flat( tree& document, std::istream& stream)
{
//
// This function would make Sean Parent cry !!!
//
auto composite = &document;
std::vector<std::string> last;
std::string line;
while( std::getline( stream, line))
{
const auto candidate = trim( line);
if( candidate.empty())
{
//
// Found nothing and we just ignore it
//
continue;
}
if( candidate.find_first_of( "#;") == 0)
{
//
// Found a comment and we just ignore it
//
continue;
}
const auto separator = line.find_first_of( '=');
if( separator != std::string::npos)
{
//
// We found a (potential) value and some data
//
auto name = trim( line.substr( 0, separator));
auto data = line.substr( separator + 1);
//
// Add it to the tree after some unmarshalling
//
composite->values.emplace( std::move( name), decode( data));
continue;
}
if( candidate.front() == '[' && candidate.back() == ']')
{
//
// Found a potential section (a.k.a. composite a.k.a. serializable)
//
//
// An internal lambda-helper to split a qualified name
//
const auto splitter = [] ( std::string qualified)
{
std::vector<std::string> result;
std::istringstream stream( std::move( qualified));
std::string name;
while( std::getline( stream, name, '.'))
{
auto candidate = trim( std::move( name) );
if( candidate.empty())
{
throw exception::archive::invalid::Document{ "Invalid name"};
}
else
{
result.push_back( std::move( candidate));
}
}
if( result.empty())
{
throw exception::archive::invalid::Document{ "Invalid name"};
}
return result;
};
//
// An internal lambda-helper to help out where to add this section
//
const auto finder = [] ( const std::vector<std::string>& last, const std::vector<std::string>& next)
{
if( next.size() > last.size())
{
return std::mismatch( last.begin(), last.end(), next.begin()).second;
}
auto match = std::mismatch( next.begin(), next.end(), last.begin());
return match.first != next.end() ? match.first : std::prev( match.first);
};
//
// First we split the string (e.g. 'foo.bar' into 'foo' and 'bar')
//
auto next = splitter( { candidate.begin() + 1, candidate.end() - 1 } );
const auto inserter = finder( last, next);
composite = &document;
//
// Search from root to find out where this should be added
//
for( auto name = next.begin(); name != inserter; ++name)
{
composite = &std::prev( composite->children.upper_bound( *name))->second;
}
//
// Add all names where they should be added
//
for( auto name = inserter; name != next.end(); ++name)
{
composite = &composite->children.emplace( *name, tree())->second;
}
//
// Keep this qualified name until next time
//
std::swap( last, next);
continue;
}
if( candidate.back() == '\\')
{
//
// TODO: Possibly append to previous data
//
// Can be done by using 'inserter' and previous.back()
//
}
//
// Unknown content
//
exception::archive::invalid::Document( "Invalid document");
}
}
} // local
} //
const tree& Load::serialize( std::istream& stream)
{
local::parse_flat( m_document, stream);
return source();
}
const tree& Load::serialize( const std::string& ini)
{
std::istringstream stream( ini);
return serialize( stream);
}
const tree& Load::source() const
{
return m_document;
}
namespace reader
{
Implementation::Implementation( const tree& document) : m_node_stack{ &document } {}
std::tuple< std::size_t, bool> Implementation::container_start( const std::size_t size, const char* const name)
{
if( name)
{
//
// We do not know whether it's a node or data
//
const auto node = m_node_stack.back()->children.equal_range( name);
if( node.first != node.second)
{
//
// Transform backwards
//
for( auto iterator = node.second; iterator != node.first; --iterator)
{
m_node_stack.push_back( &std::prev( iterator)->second);
}
return std::make_tuple( std::distance( node.first, node.second), true);
}
const auto data = m_node_stack.back()->values.equal_range( name);
if( data.first != data.second)
{
//
// Transform backwards
//
for( auto iterator = data.second; iterator != data.first; --iterator)
{
m_data_stack.push_back( &std::prev( iterator)->second);
}
return std::make_tuple( std::distance( data.first, data.second), true);
}
}
else
{
//
// An idea to handle this is by creating fake serializable
//
// E.g. [@name], [@name.@name], etc or something
//
throw exception::archive::invalid::Node{ "Nested containers not supported (yet)"};
}
//
// Note that we return 'true' anyway
//
return std::make_tuple( 0, true);
}
void Implementation::container_end( const char* const name)
{
}
bool Implementation::serialtype_start( const char* const name)
{
if( name)
{
const auto node = m_node_stack.back()->children.find( name);
if( node != m_node_stack.back()->children.end())
{
m_node_stack.push_back( &node->second);
}
else
{
return false;
}
}
else
{
//
// It must have been a container-content and thus already found
//
}
return true;
}
void Implementation::serialtype_end( const char* const name)
{
m_node_stack.pop_back();
}
bool Implementation::value_start( const char* name)
{
if( name)
{
const auto data = m_node_stack.back()->values.find( name);
if( data != m_node_stack.back()->values.end())
{
m_data_stack.push_back( &data->second);
}
else
{
return false;
}
}
else
{
//
// It must have been a container-content and thus already found
//
}
return true;
}
void Implementation::value_end( const char* name)
{
m_data_stack.pop_back();
}
void Implementation::decode( const std::string& data, bool& value) const
{
std::istringstream stream( data);
stream >> std::boolalpha >> value;
}
void Implementation::decode( const std::string& data, char& value) const
{
value = data.empty() ? '\0' : data.front();
}
void Implementation::decode( const std::string& data, std::string& value) const
{
value = data;
}
void Implementation::decode( const std::string& data, std::vector<char>& value) const
{
//
// Binary data might be double-decoded (in the end)
//
value = common::transcode::base64::decode( data);
}
} // reader
namespace
{
namespace local
{
// TODO: Make it streamable
std::string encode( const std::string& data)
{
std::ostringstream stream;
for( const auto sign : data)
{
// TODO: handle all control-characters (and back-slash)
//if( std::iscntrl( sign, std::locale::classic())){ ... }
switch( sign)
{
case '\\': stream << "\\\\"; break;
case '\0': stream << "\\0"; break;
case '\a': stream << "\\a"; break;
case '\b': stream << "\\b"; break;
case '\f': stream << "\\f"; break;
case '\n': stream << "\\n"; break;
case '\r': stream << "\\r"; break;
case '\t': stream << "\\t"; break;
case '\v': stream << "\\v"; break;
default: stream.put( sign); break;
}
}
return stream.str();
}
void write_flat( const tree& node, std::ostream& stream, const std::string& name = "")
{
for( const auto& value : node.values)
{
stream << value.first << '=' << encode( value.second) << '\n';
}
for( const auto& child : node.children)
{
const auto qualified = name.empty() ? child.first : name + '.' + child.first;
//
// Let's print useless empty sections anyway ('cause
// reading need 'em as of today)
//
//if( ! child.second.values.empty())
{
stream << '\n' << '[' << qualified << ']' << '\n';
}
write_flat( child.second, stream, qualified);
}
}
/*
void write_tree( const tree& node, std::ostream& stream, std::string::size_type indent = 0)
{
for( const auto& value : node.values)
{
stream << std::string( indent, ' ') << value.first << '=' << value.second << '\n';
}
for( const auto& child : node.children)
{
++indent;
stream << '\n' << std::string( indent, ' ') << '[' << child.first << ']' << '\n';
write_tree( child.second, stream, indent);
++indent;
}
}
*/
} // local
} //
Save::Save() = default;
Save::~Save() = default;
void Save::serialize( std::ostream& stream) const
{
local::write_flat( m_document, stream);
}
void Save::serialize( std::string& ini) const
{
std::ostringstream stream;
serialize( stream);
ini.assign( stream.str());
}
tree& Save::target()
{
return m_document;
}
namespace writer
{
Implementation::Implementation( tree& document) : m_node_stack{ &document } {}
std::size_t Implementation::container_start( const std::size_t size, const char* const name)
{
//
// We do not know where it's node or data
//
if( name)
{
m_name_stack.push_back( name);
}
else
{
throw exception::archive::invalid::Node{ "Nested containers not supported (yet)"};
}
return size;
}
void Implementation::container_end( const char* const name)
{
if( name)
{
m_name_stack.pop_back();
}
}
void Implementation::serialtype_start( const char* const name)
{
const auto final = name ? name : m_name_stack.back();
const auto child = m_node_stack.back()->children.emplace( final, tree());
m_node_stack.push_back( &child->second);
}
void Implementation::serialtype_end( const char* const name)
{
m_node_stack.pop_back();
}
void Implementation::write( std::string data, const char* const name)
{
const auto final = name ? name : m_name_stack.back();
m_node_stack.back()->values.emplace( final, std::move( data));
}
std::string Implementation::encode( const bool& value) const
{
std::ostringstream stream;
stream << std::boolalpha << value;
return stream.str();
}
std::string Implementation::encode( const char& value) const
{
return std::string{ value};
}
std::string Implementation::encode( const std::vector<char>& value) const
{
//
// Binary data might be double-encoded
//
return common::transcode::base64::encode( value);
}
} // writer
} // xml
} // archive
} // sf
} // casual
| 20,497 | 4,572 |
#include "Preprocessor.h"
#include <functional>
namespace MoonGlare::Renderer::Resources::Shader {
bool ShaderFileCache::ReadFile(const std::string &FName, const ReadBuffer *&out) {
auto it = loadedFiles.find(FName);
if (it != loadedFiles.end()) {
if (!it->second.has_value()) {
AddLogf(Warning, "Unable to load file '%s'", FName.c_str());
return false;
}
out = &it->second.value();
return true;
}
StarVFS::ByteTable data;
if (!GetFileSystem()->OpenFile(data, "file:///Shaders/" + FName)) {
return false;
}
ReadBuffer buf;
std::stringstream ss;
ss << data.c_str();
while (ss) {
std::string line;
std::getline(ss, line);
buf.emplace_back(std::move(line));
}
loadedFiles[FName] = std::move(buf);
out = &loadedFiles[FName].value();
return true;
}
//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
const std::array<Preprocessor::PreprocessorToken, 1> Preprocessor::s_Tokens = {
PreprocessorToken{ std::regex(R"(^\s*#include\s+[<"]([/A-Za-z0-9_\.]+)[">]\s*)"), &Preprocessor::IncludeToken },
};
Preprocessor::Preprocessor(ShaderFileCache *fc):
fileCache(fc) {
}
Preprocessor::~Preprocessor() {
}
void Preprocessor::PushFile(const std::string & Name) {
try {
if (outputBuffer.empty())
GenerateDefines();
Process(Name, 0);
}
catch (MissingFileException &e) {
if (e.m_IncludeLevel > 0) {
AddLogf(Error, "Error while processing file %s", Name.c_str());
throw e;
}
}
catch (ParseException &e) {
AddLogf(Error, "Error while processing file %s", Name.c_str());
throw e;
}
}
void Preprocessor::GetOutput(std::string &Output) {
std::stringstream ss;
for (auto line : outputBuffer)
ss << line << std::endl;
Output = ss.str();
}
void Preprocessor::ClearOutput() {
includedFiles.clear();
outputBuffer.clear();
}
void Preprocessor::Clear() {
ClearOutput();
defines.clear();
}
void Preprocessor::Process(const std::string &FName, int level) {
if (includedFiles.find(FName) != includedFiles.end()) {
outputBuffer.pushf("//@ skip[%d] %s - included", level, FName.c_str());
return;
}
includedFiles[FName] = true;
const ReadBuffer *lines;
if (!fileCache->ReadFile(FName, lines)) {
if (level > 0) {
AddLogf(Error, "Unable to load file '%s'", FName.c_str());
}
throw MissingFileException{ FName , level };
}
outputBuffer.pushf("//@ start[%d] %s", level, FName.c_str());
unsigned linenum = 0;
try {
outputBuffer.push(fmt::format("#line {}", 1));
for(const auto &line : *lines) {
++linenum;
bool handled = false;
std::smatch match;
for (auto token : s_Tokens) {
if (std::regex_search(line, match, token.regExp)) {
outputBuffer.pushs("//@ %s", line);
(this->*token.handler)(FName, line, level, std::move(match));
outputBuffer.push(fmt::format("#line {}", linenum));
handled = true;
break;
}
}
if (!handled) {
outputBuffer.push_back(line);
}
}
}
catch (ParseException &e) {
AddLogf(Error, "Error while processing included file %s at line %d", FName.c_str(), linenum);
throw e;
}
outputBuffer.pushf("//@ end[%d] %s", level, FName.c_str());
}
void Preprocessor::GenerateDefines() {
for (auto &it : defines) {
std::string line;
line = "#define ";
line += it.first;
line += " ";
line += it.second;
outputBuffer.push_back(line);
}
}
void Preprocessor::IncludeToken(const std::string &FName, const std::string &line, int level, std::smatch match) {
std::string iName = match[1];
try {
outputBuffer.pushf("//@ pause[%d] %s", level, FName.c_str());
Process(iName, level + 1);
outputBuffer.pushf("//@ continue[%d] %s", level, FName.c_str());
}
catch (ParseException &) {
AddLogf(Error, "Error while processing included file %s", iName.c_str());
throw;
}
}
} //namespace MoonGlare::Asset::Shader
| 4,516 | 1,422 |
#include <bits/stdc++.h>
using namespace std;
#define PI 2*acos(0)
#define ll long long int
bool myAssert(bool b);
void testDrivenDevelopment();
int start(int argc=0, char const *argv[] = NULL);
ll n,k;
vector<int> *g;
bool *isvisited;
int main(int argc, char const *argv[])
{
/* code */
/* Soln soln */
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
/*
cout << setprecision(8);
cout << num1 << endl;
*/
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>n>>k;
ll count=0;
/*
for(int i=1; i<=k; i++){
for(int j=i+1; j<=k; j++){
count+=2;
}
}*/
double temp1=0,temp2 = log(n);
for(int i=1; i<k; i++){
temp1+=log(i);
if(temp1>=temp2){ break; }
}
if(temp1<temp2){
cout<<"NO\n";
exit(0);
}else{
cout<<"YES\n";
}
/*
if(count < n){
cout<<"NO\n";
exit(0);
}else{
cout<<"YES\n";
}*/
count=0;
for(int i=1; i<k; i++){
for(int j=i+1; j<=k; j++){
cout<<i<<" "<<j<<"\n";
count++;
if(count == n){ exit(0); }
cout<<j<<" "<<i<<"\n";
count++;
if(count == n){ exit(0); }
}
}
return 0;
}
| 1,177 | 539 |
/*
Pensemos en cuánto va a tener cada persona despues de darles el dinero
Como quiero dar lo menos posible, quiero que esta altura sea minima
esta altura puede ser la de la persona con mas dinero
no puede ser menos porque tendria que quitarle dinero a esta persona
y si fuera mayor que esta, involucraría dar más dinero
Reto: hazlo con memoria O(1), es decir, sin usar el arreglo
*/
#include <iostream>
using namespace std;
int main(){
int n;
cin>>n;
int welfare[n], maxWelfare;
maxWelfare = 0;
for(int i = 0; i < n; i++){
cin>>welfare[i];
maxWelfare = max(maxWelfare, welfare[i]);
}
//calculamos la cantidad de monedas que debemos dar
int monedas, totalQueDoy = 0;
for(int i = 0; i < n; ++i){
monedas = maxWelfare - welfare[i];
totalQueDoy += monedas;
}
cout<<totalQueDoy<<"\n";
return 0;
} | 916 | 332 |
#include "geometry/barycentre_calculator.hpp"
#include <vector>
#include "geometry/frame.hpp"
#include "geometry/grassmann.hpp"
#include "gtest/gtest.h"
#include "quantities/named_quantities.hpp"
#include "quantities/quantities.hpp"
#include "quantities/si.hpp"
#include "testing_utilities/almost_equals.hpp"
namespace principia {
using geometry::Frame;
using quantities::Entropy;
using quantities::KinematicViscosity;
using testing_utilities::AlmostEquals;
namespace si = quantities::si;
namespace geometry {
class BarycentreCalculatorTest : public testing::Test {
protected:
using World = Frame<enum class WorldTag>;
BarycentreCalculatorTest()
: b1_({1 * si::Unit<Entropy>,
-2 * si::Unit<Entropy>,
3 * si::Unit<Entropy>}),
b2_({-9 * si::Unit<Entropy>,
8 * si::Unit<Entropy>,
7 * si::Unit<Entropy>}),
k1_(4 * si::Unit<KinematicViscosity>),
k2_(5 * si::Unit<KinematicViscosity>) {}
Bivector<Entropy, World> b1_;
Bivector<Entropy, World> b2_;
KinematicViscosity k1_;
KinematicViscosity k2_;
};
using BarycentreCalculatorDeathTest = BarycentreCalculatorTest;
TEST_F(BarycentreCalculatorDeathTest, Error) {
using Calculator = BarycentreCalculator<Bivector<Entropy, World>, double>;
EXPECT_DEATH({
Calculator calculator;
calculator.Get();
}, "Empty BarycentreCalculator");
}
TEST_F(BarycentreCalculatorTest, Bivector) {
BarycentreCalculator<Bivector<Entropy, World>, KinematicViscosity>
barycentre_calculator;
barycentre_calculator.Add(b1_, k1_);
barycentre_calculator.Add(b2_, k2_);
EXPECT_THAT(barycentre_calculator.Get(),
AlmostEquals(
Bivector<Entropy, World>({(-41.0 / 9.0) * si::Unit<Entropy>,
(32.0 / 9.0) * si::Unit<Entropy>,
(47.0 / 9.0) * si::Unit<Entropy>}),
0));
}
TEST_F(BarycentreCalculatorTest, Scalar) {
BarycentreCalculator<KinematicViscosity, double> barycentre_calculator;
barycentre_calculator.Add(k1_, -3);
barycentre_calculator.Add(k2_, 7);
EXPECT_THAT(barycentre_calculator.Get(),
AlmostEquals((23.0 / 4.0) * si::Unit<KinematicViscosity>, 0));
}
} // namespace geometry
} // namespace principia
| 2,314 | 830 |
#pragma once
// This file is generated from the Game's Reflection data
#include <cstdint>
#include <RED4ext/Common.hpp>
#include <RED4ext/REDhash.hpp>
#include <RED4ext/Handle.hpp>
namespace RED4ext
{
namespace anim { struct AnimNode_Base; }
namespace anim {
struct PoseLink
{
static constexpr const char* NAME = "animPoseLink";
static constexpr const char* ALIAS = NAME;
WeakHandle<anim::AnimNode_Base> node; // 00
uint8_t unk10[0x18 - 0x10]; // 10
};
RED4EXT_ASSERT_SIZE(PoseLink, 0x18);
} // namespace anim
} // namespace RED4ext
| 555 | 210 |
// TIME COMPLEXITY : O(V + E), where V is the number of vertices, and E is the number of Edges.
#include<bits/stdc++.h>
using namespace std;
template<typename T>
class graphmap{
map<T, list<T> >l;
map<T, list<pair<T,int>>> m;
public:
graphmap(){
}
void addedge(T u, T v, bool bidir=true){
l[u].push_back(v);
if(bidir){
l[v].push_back(u);
}
}
void addedge(T u, T v, bool bidir,int dist){
m[u].push_back(make_pair(v,dist));
if(bidir){
m[v].push_back(make_pair(u,dist));
}
}
void printgraph(){
for(auto i: l){
cout<<i.first<<"-";
for(auto vertex: i.second){
cout<<vertex<<",";
}
cout<<endl;
}
}
helper(T src , map<T, bool> &visited){
visited[src]=true;
cout<<src<<"-";
for(auto child: l[src]){
if(!visited[child]){
helper(child, visited);}
}
}
void dfs(T src){
map<T,bool> visited;
helper(src, visited);
// non connected graphs
for(auto i: l){
T child = i.first;
if(!visited[child]){
helper(child, visited);}
}
}
};
int main(){
graphmap<int> g;
g.addedge(1,2,true);
g.addedge(2,3,true);
g.addedge(3,4,true);
g.addedge(1,4,true);
g.addedge(5,3,true);
g.addedge(3,1,true);
cout<<"DFS :: ";
g.dfs(2);
return 0;
}
| 1,279 | 580 |
/*
* Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License, version 2.0,
* as published by the Free Software Foundation.
*
* This program is also distributed with certain software (including
* but not limited to OpenSSL) that is licensed under separate terms, as
* designated in a particular file or component or in included license
* documentation. The authors of MySQL hereby grant you an additional
* permission to link the program and your derivative works with the
* separately licensed software that they have included with MySQL.
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
* the GNU General Public License, version 2.0, for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "mysql-secret-store/windows-credential/windows_credential_helper.h"
#include <WinCred.h>
#include <memory>
#include <utility>
#include "mysqlshdk/libs/utils/utils_file.h"
#include "mysqlshdk/libs/utils/utils_general.h"
#include "mysqlshdk/libs/utils/utils_string.h"
using mysql::secret_store::common::get_helper_exception;
using mysql::secret_store::common::Helper_exception;
using mysql::secret_store::common::Helper_exception_code;
namespace mysql {
namespace secret_store {
namespace windows_credential {
namespace {
constexpr auto k_company_name = "Oracle";
constexpr auto k_name_separator = "|";
constexpr DWORD k_credential_type = CRED_TYPE_GENERIC; // generic credential
} // namespace
Windows_credential_helper::Windows_credential_helper()
: common::Helper("windows-credential", shcore::get_long_version(),
MYSH_HELPER_COPYRIGHT),
m_persist_mode{CRED_PERSIST_LOCAL_MACHINE} {}
void Windows_credential_helper::check_requirements() {
DWORD maximum_persist[CRED_TYPE_MAXIMUM];
if (!CredGetSessionTypes(CRED_TYPE_MAXIMUM, maximum_persist)) {
throw Helper_exception{"Failed to check persistent mode: " +
shcore::get_last_error()};
}
if (maximum_persist[k_credential_type] < CRED_PERSIST_LOCAL_MACHINE) {
throw Helper_exception{"Credentials cannot be persisted"};
}
m_persist_mode = maximum_persist[k_credential_type];
}
void Windows_credential_helper::store(const common::Secret &secret) {
auto url_keyword = get_url_keyword();
auto secret_type_keyword = get_secret_type_keyword();
CREDENTIAL_ATTRIBUTE attributes[2];
attributes[0].Keyword = (LPSTR)url_keyword.c_str();
attributes[0].Flags = 0;
attributes[0].ValueSize = secret.id.url.length();
attributes[0].Value = (LPBYTE)secret.id.url.c_str();
attributes[1].Keyword = (LPSTR)secret_type_keyword.c_str();
attributes[1].Flags = 0;
attributes[1].ValueSize = secret.id.secret_type.length();
attributes[1].Value = (LPBYTE)secret.id.secret_type.c_str();
auto name = get_name(secret.id);
CREDENTIAL cred;
cred.Flags = 0; // no flags
cred.Type = k_credential_type;
cred.TargetName = (LPSTR)name.c_str(); // unique name
cred.Comment = nullptr; // no comments!
cred.LastWritten = {0, 0}; // ignored for write operations
cred.CredentialBlobSize = secret.secret.length();
cred.CredentialBlob = (LPBYTE)secret.secret.c_str();
cred.Persist = m_persist_mode;
cred.AttributeCount = shcore::array_size(attributes);
cred.Attributes = attributes;
cred.TargetAlias = nullptr; // ignored in case of CRED_TYPE_GENERIC
cred.UserName = nullptr; // ignored in case of CRED_TYPE_GENERIC
if (!CredWrite(&cred, 0)) {
throw Helper_exception{"Failed to store the secret: " +
shcore::get_last_error()};
}
}
void Windows_credential_helper::get(const common::Secret_id &id,
std::string *secret) {
auto name = get_name(id);
PCREDENTIAL cred = nullptr;
if (!CredRead(name.c_str(), k_credential_type, 0, &cred)) {
if (GetLastError() == ERROR_NOT_FOUND) {
throw get_helper_exception(Helper_exception_code::NO_SUCH_SECRET);
} else {
throw Helper_exception{"Failed to get the secret: " +
shcore::get_last_error()};
}
} else {
const std::unique_ptr<CREDENTIAL, decltype(&CredFree)> deleter{cred,
CredFree};
*secret = std::string(reinterpret_cast<char *>(cred->CredentialBlob),
cred->CredentialBlobSize);
}
}
void Windows_credential_helper::erase(const common::Secret_id &id) {
auto name = get_name(id);
if (!CredDelete(name.c_str(), k_credential_type, 0)) {
if (GetLastError() == ERROR_NOT_FOUND) {
throw get_helper_exception(Helper_exception_code::NO_SUCH_SECRET);
} else {
throw Helper_exception{"Failed to erase the secret: " +
shcore::get_last_error()};
}
}
}
void Windows_credential_helper::list(std::vector<common::Secret_id> *secrets) {
PCREDENTIAL *credentials = nullptr;
DWORD count = 0;
auto filter = get_search_pattern();
if (!CredEnumerate(filter.c_str(), 0, &count, &credentials)) {
if (GetLastError() == ERROR_NOT_FOUND) {
// empty list, not an error
return;
} else {
throw Helper_exception{"Failed to list the secrets: " +
shcore::get_last_error()};
}
} else {
const std::unique_ptr<PCREDENTIAL, decltype(&CredFree)> deleter{credentials,
CredFree};
const auto url_keyword = get_url_keyword();
const auto secret_type_keyword = get_secret_type_keyword();
for (DWORD i = 0; i < count; ++i) {
std::string url;
std::string secret_type;
for (DWORD j = 0; j < credentials[i]->AttributeCount; ++j) {
const auto &attribute = credentials[i]->Attributes[j];
const auto keyword = std::string{attribute.Keyword};
auto value = std::string(reinterpret_cast<char *>(attribute.Value),
attribute.ValueSize);
if (keyword == url_keyword) {
url = std::move(value);
} else if (keyword == secret_type_keyword) {
secret_type = std::move(value);
}
}
if (url.empty() || secret_type.empty()) {
throw Helper_exception{"Invalid entry detected"};
}
secrets->emplace_back(common::Secret_id{secret_type, url});
}
}
}
std::string Windows_credential_helper::get_name_prefix() const {
return shcore::str_join(std::vector<std::string>{k_company_name, name()},
k_name_separator);
}
std::string Windows_credential_helper::get_name(
const common::Secret_id &id) const {
return shcore::str_join(
std::vector<std::string>{get_name_prefix(), id.secret_type, id.url},
k_name_separator);
}
std::string Windows_credential_helper::get_search_pattern() const {
return shcore::str_join(std::vector<std::string>{get_name_prefix(), "*"},
k_name_separator);
}
std::string Windows_credential_helper::get_keyword_prefix() const {
return shcore::str_join(
std::vector<std::string>{k_company_name, name() + "-"}, "_");
}
std::string Windows_credential_helper::get_url_keyword() const {
return get_keyword_prefix() + "url";
}
std::string Windows_credential_helper::get_secret_type_keyword() const {
return get_keyword_prefix() + "secret-type";
}
} // namespace windows_credential
} // namespace secret_store
} // namespace mysql
| 7,890 | 2,492 |
//
// GDCL Multigraph Framework
//
// Sink.cpp: implementation of sink filter and input pin
//
// Copyright (c) GDCL 2004. All Rights Reserved.
// You are free to re-use this as the basis for your own filter development,
// provided you retain this copyright notice in the source.
// http://www.gdcl.co.uk
#pragma warning(push)
#pragma warning(disable:4312)
#pragma warning(disable:4995)
#include "litiv/3rdparty/dshowbase/streams.h"
#include <comdef.h>
_COM_SMARTPTR_TYPEDEF(IMemAllocator, IID_IMemAllocator);
_COM_SMARTPTR_TYPEDEF(IGraphBuilder, IID_IGraphBuilder);
_COM_SMARTPTR_TYPEDEF(IBaseFilter, IID_IBaseFilter);
_COM_SMARTPTR_TYPEDEF(IEnumMediaTypes, IID_IEnumMediaTypes);
_COM_SMARTPTR_TYPEDEF(IMediaSample, IID_IMediaSample);
_COM_SMARTPTR_TYPEDEF(IMediaSample2, IID_IMediaSample2);
_COM_SMARTPTR_TYPEDEF(IEnumFilters, IID_IEnumFilters);
_COM_SMARTPTR_TYPEDEF(IQualityControl, IID_IQualityControl);
_COM_SMARTPTR_TYPEDEF(IEnumPins, IID_IEnumPins);
_COM_SMARTPTR_TYPEDEF(IPin, IID_IPin);
_COM_SMARTPTR_TYPEDEF(IEnumMediaTypes, IID_IEnumMediaTypes);
_COM_SMARTPTR_TYPEDEF(IMediaControl, IID_IMediaControl);
_COM_SMARTPTR_TYPEDEF(IMediaSeeking, IID_IMediaSeeking);
_COM_SMARTPTR_TYPEDEF(IVideoWindow, IID_IVideoWindow);
_COM_SMARTPTR_TYPEDEF(IBasicVideo, IID_IBasicVideo);
_COM_SMARTPTR_TYPEDEF(IPinConnection, IID_IPinConnection);
#pragma warning(pop)
#include "litiv/3rdparty/dshowbase/gmf/smartPtr.h"
#include "litiv/3rdparty/dshowbase/gmf/bridge.h"
#include "litiv/3rdparty/dshowbase/gmf/sink.h"
#pragma warning(disable: 4786) // debug info truncated
#include <list>
using namespace std;
#include <sstream>
BridgeSink::BridgeSink(BridgeController* pController)
: m_tFirst(0),
m_bLastDiscarded(false),
m_nEOS(0),
m_dwROT(0),
CBaseFilter(NAME("BridgeSink filter"), NULL, &m_csFilter, GUID_NULL)
{
HRESULT hr = S_OK;
m_nPins = pController->StreamCount();
m_pPins = new smart_ptr<BridgeSinkInput>[m_nPins];
for(int n = 0; n < m_nPins; n++)
{
ostringstream strm;
strm << "Input " << (n+1);
_bstr_t strName = strm.str().c_str();
m_pPins[n] = new BridgeSinkInput(this, pController->GetStream(n), m_pLock, &hr, strName);
}
LOG((TEXT("Sink 0x%x has %d pins"), this, m_nPins));
}
STDMETHODIMP
BridgeSink::NonDelegatingQueryInterface(REFIID iid, void** ppv)
{
if (iid == IID_IMediaSeeking)
{
// implement IMediaSeeking directly ourselves, not via
// a pass-through proxy, so that we can aggregate multiple input pins
// (needed for WMV playback)
return GetInterface((IMediaSeeking*)this, ppv);
} else if (iid == __uuidof(IBridgeSink))
{
return GetInterface((IBridgeSink*)this, ppv);
} else {
return CBaseFilter::NonDelegatingQueryInterface(iid, ppv);
}
}
int
BridgeSink::GetPinCount()
{
return m_nPins;
}
CBasePin*
BridgeSink::GetPin(int n)
{
if ((n < 0) || (n >= m_nPins))
{
return NULL;
}
return m_pPins[n];
}
STDMETHODIMP
BridgeSink::GetBridgePin(int nPin, BridgeSinkInput** ppPin)
{
if ((nPin < 0) || (nPin >= m_nPins))
{
return E_INVALIDARG;
}
*ppPin = m_pPins[nPin];
return S_OK;
}
void
BridgeSink::OnEOS(bool bConnected)
{
{
CAutoLock lock(&m_csEOS);
m_nEOS += 1;
if (!IsAtEOS())
{
LOG((TEXT("Sink 0x%x EOS discarded"), this));
return;
}
}
if (bConnected)
{
BridgeController* pC = m_pPins[0]->GetStream()->GetController();
LOG((TEXT("Sink 0x%x EOS"), this));
pC->OnEndOfSegment();
}
}
STDMETHODIMP_(BOOL) BridgeSink::IsAtEOS()
{
CAutoLock lock(&m_csEOS);
long nPins = 0;
for (int n = 0; n < m_nPins; n++)
{
if (m_pPins[n]->IsConnected())
{
nPins++;
}
}
return (m_nEOS == nPins);
}
void
BridgeSink::ResetEOSCount()
{
CAutoLock lock(&m_csEOS);
m_nEOS = 0;
m_tFirst = 0;
m_bLastDiscarded = false;
LOG((TEXT("Sink 0x%x ResetEOSCount"), this));
}
STDMETHODIMP
BridgeSink::Stop()
{
LOG((TEXT("Sink 0x%x Stop"), this));
HRESULT hr = CBaseFilter::Stop();
ResetEOSCount();
return hr;
}
void
BridgeSink::Discard()
{
CAutoLock lock(&m_csEOS);
m_bLastDiscarded = true;
}
void
BridgeSink::AdjustTime(IMediaSample* pIn)
{
CAutoLock lock(&m_csEOS);
REFERENCE_TIME tStart, tEnd;
if (SUCCEEDED(pIn->GetTime(&tStart, &tEnd)))
{
if (m_bLastDiscarded)
{
LOG((TEXT("Sink 0x%x setting offset %d msecs"), this, long(tStart / 10000)));
m_tFirst = tStart;
m_bLastDiscarded = false;
}
if (m_tFirst != 0)
{
LOG((TEXT("Sink adjusting %d to %d msecs"), long(tStart/10000), long((tStart-m_tFirst)/10000)));
}
tStart -= m_tFirst;
tEnd -= m_tFirst;
pIn->SetTime(&tStart, &tEnd);
}
}
// register in the running object table for graph debugging
STDMETHODIMP
BridgeSink::JoinFilterGraph(IFilterGraph * pGraph, LPCWSTR pName)
{
HRESULT hr = CBaseFilter::JoinFilterGraph(pGraph, pName);
// for debugging, we register in the ROT so that you can use
// Graphedt's Connect command to view the graphs
// disabled by default owing to refcount leak issue
if (false) //SUCCEEDED(hr))
{
if (pGraph == NULL)
{
if (m_dwROT) {
IRunningObjectTablePtr pROT;
if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
pROT->Revoke(m_dwROT);
}
}
} else {
IMonikerPtr pMoniker;
IRunningObjectTablePtr pROT;
if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
ostringstream strm;
DWORD graphaddress = (DWORD)((DWORD_PTR)(IUnknown*)pGraph) & 0xFFFFFFFF;
strm << "FilterGraph " << hex << graphaddress << " pid " << hex << GetCurrentProcessId();
_bstr_t strName = strm.str().c_str();
HRESULT hr = CreateItemMoniker(L"!", strName, &pMoniker);
if (SUCCEEDED(hr)) {
hr = pROT->Register(0, pGraph, pMoniker, &m_dwROT);
}
}
}
}
return hr;
}
// BridgeSink seeking implementation
// holds all the input pins that support seeking
class SeekingCollection
{
public:
typedef list<IMediaSeeking*>::iterator iterator;
// if bSet, only accept settable pins
SeekingCollection(CBaseFilter* pFilter)
{
for (int i = 0; i < pFilter->GetPinCount(); i++)
{
CBasePin* pPin = pFilter->GetPin(i);
PIN_DIRECTION pindir;
pPin->QueryDirection(&pindir);
if (pindir == PINDIR_INPUT)
{
IMediaSeekingPtr pSeek = pPin->GetConnected();
if (pSeek != NULL)
{
m_Pins.push_back(pSeek.Detach());
}
}
}
}
~SeekingCollection()
{
while (!m_Pins.empty())
{
IMediaSeekingPtr pSeek(m_Pins.front(), 0);
m_Pins.pop_front();
pSeek = NULL;
}
}
iterator Begin()
{
return m_Pins.begin();
}
iterator End()
{
return m_Pins.end();
}
private:
list<IMediaSeeking*> m_Pins;
};
// --- not implemented -------------
STDMETHODIMP
BridgeSink::GetCurrentPosition(LONGLONG *pCurrent)
{
UNREFERENCED_PARAMETER(pCurrent);
// implemented in graph manager using stream time
return E_NOTIMPL;
}
// ---- by aggregation of input pin responses --------------
STDMETHODIMP
BridgeSink::GetCapabilities(DWORD * pCapabilities)
{
SeekingCollection pins(this);
DWORD caps = 0;
for (SeekingCollection::iterator it = pins.Begin(); it != pins.End(); it++)
{
IMediaSeekingPtr pSeek = *it;
DWORD capsThis;
HRESULT hr = pSeek->GetCapabilities(&capsThis);
if (SUCCEEDED(hr))
{
caps |= capsThis;
}
}
*pCapabilities = caps;
return S_OK;
}
STDMETHODIMP
BridgeSink::SetPositions(LONGLONG * pCurrent, DWORD dwCurrentFlags
, LONGLONG * pStop, DWORD dwStopFlags)
{
// pass call to all pins. Fails if any fail.
SeekingCollection pins(this);
HRESULT hr = S_OK;
for (SeekingCollection::iterator it = pins.Begin(); it != pins.End(); it++)
{
IMediaSeekingPtr pSeek = *it;
if (pSeek->IsUsingTimeFormat(&TIME_FORMAT_MEDIA_TIME) == S_OK)
{
HRESULT hrThis = pSeek->SetPositions(pCurrent, dwCurrentFlags, pStop, dwStopFlags);
if (FAILED(hrThis) && (hrThis != E_NOTIMPL) && SUCCEEDED(hr))
{
hr = hrThis;
}
}
}
return hr;
}
STDMETHODIMP
BridgeSink::GetPositions(LONGLONG * pCurrent,
LONGLONG * pStop)
{
// cannot really aggregate this -- just return the
// first one and assume they are all the same (they will
// be if we set the params)
SeekingCollection pins(this);
HRESULT hr;
if (pins.Begin() == pins.End())
{
hr = E_NOINTERFACE;
} else {
IMediaSeekingPtr pSeek = *pins.Begin();
hr = pSeek->GetPositions(pCurrent, pStop);
}
return hr;
}
STDMETHODIMP
BridgeSink::GetAvailable(LONGLONG * pEarliest, LONGLONG * pLatest)
{
// the available section reported is what is common to all inputs
LONGLONG tEarly = 0;
LONGLONG tLate = 0x7fffffffffffffff;
SeekingCollection pins(this);
for (SeekingCollection::iterator it = pins.Begin(); it != pins.End(); it++)
{
IMediaSeekingPtr pSeek = *it;
LONGLONG tThisEarly, tThisLate;
HRESULT hr = pSeek->GetAvailable(&tThisEarly, &tThisLate);
if (SUCCEEDED(hr))
{
if (tThisEarly > tEarly)
{
tEarly = tThisEarly;
}
if (tThisLate < tLate)
{
tLate = tThisLate;
}
}
}
*pEarliest = tEarly;
*pLatest = tLate;
return S_OK;
}
STDMETHODIMP
BridgeSink::SetRate(double dRate)
{
// pass call to all pins. Fails if any fail.
SeekingCollection pins(this);
HRESULT hr = S_OK;
for (SeekingCollection::iterator it = pins.Begin(); it != pins.End(); it++)
{
IMediaSeekingPtr pSeek = *it;
HRESULT hrThis = pSeek->SetRate(dRate);
if (FAILED(hrThis) && SUCCEEDED(hr))
{
hr = hrThis;
}
}
return hr;
}
STDMETHODIMP
BridgeSink::GetRate(double * pdRate)
{
// cannot really aggregate this -- just return the
// first one and assume they are all the same (they will
// be if we set the params)
SeekingCollection pins(this);
HRESULT hr;
if (pins.Begin() == pins.End())
{
hr = E_NOINTERFACE;
} else {
IMediaSeekingPtr pSeek = *pins.Begin();
hr = pSeek->GetRate(pdRate);
}
return hr;
}
STDMETHODIMP
BridgeSink::GetPreroll(LONGLONG * pllPreroll)
{
// the preroll requirement is the longest of any input
SeekingCollection pins(this);
LONGLONG tPreroll = 0;
for (SeekingCollection::iterator it = pins.Begin(); it != pins.End(); it++)
{
IMediaSeekingPtr pSeek = *it;
LONGLONG tThis;
HRESULT hr = pSeek->GetPreroll(&tThis);
if (SUCCEEDED(hr))
{
if (tThis > tPreroll)
{
tPreroll = tThis;
}
}
}
*pllPreroll = tPreroll;
return S_OK;
}
STDMETHODIMP
BridgeSink::GetDuration(LONGLONG *pDuration)
{
// the duration we report is the longest of any input duration
SeekingCollection pins(this);
LONGLONG tDur = 0;
for (SeekingCollection::iterator it = pins.Begin(); it != pins.End(); it++)
{
IMediaSeekingPtr pSeek = *it;
LONGLONG tThis;
HRESULT hr = pSeek->GetDuration(&tThis);
if (SUCCEEDED(hr))
{
if (tThis > tDur)
{
tDur = tThis;
}
}
}
*pDuration = tDur;
return S_OK;
}
STDMETHODIMP
BridgeSink::GetStopPosition(LONGLONG *pStop)
{
// cannot really aggregate this -- just return the
// first one and assume they are all the same (they will
// be if we set the params)
SeekingCollection pins(this);
HRESULT hr;
if (pins.Begin() == pins.End())
{
hr = E_NOINTERFACE;
} else {
IMediaSeekingPtr pSeek = *pins.Begin();
hr = pSeek->GetStopPosition(pStop);
}
return hr;
}
// -- implemented directly here --------------
STDMETHODIMP
BridgeSink::CheckCapabilities(DWORD * pCapabilities )
{
DWORD dwActual;
GetCapabilities(&dwActual);
if (*pCapabilities & (~dwActual)) {
return S_FALSE;
}
return S_OK;
}
STDMETHODIMP
BridgeSink::IsFormatSupported(const GUID * pFormat)
{
if (*pFormat == TIME_FORMAT_MEDIA_TIME) {
return S_OK;
}
return S_FALSE;
}
STDMETHODIMP
BridgeSink::QueryPreferredFormat(GUID * pFormat)
{
*pFormat = TIME_FORMAT_MEDIA_TIME;
return S_OK;
}
STDMETHODIMP
BridgeSink::GetTimeFormat(GUID *pFormat)
{
return QueryPreferredFormat(pFormat);
}
STDMETHODIMP
BridgeSink::IsUsingTimeFormat(const GUID * pFormat)
{
GUID guidActual;
HRESULT hr = GetTimeFormat(&guidActual);
if (SUCCEEDED(hr) && (guidActual == *pFormat)) {
return S_OK;
} else {
return S_FALSE;
}
}
STDMETHODIMP
BridgeSink::SetTimeFormat(const GUID * pFormat)
{
if ((*pFormat == TIME_FORMAT_MEDIA_TIME) ||
(*pFormat == TIME_FORMAT_NONE))
{
return S_OK;
} else {
return E_NOTIMPL;
}
}
STDMETHODIMP
BridgeSink::ConvertTimeFormat(LONGLONG * pTarget, const GUID * pTargetFormat,
LONGLONG Source, const GUID * pSourceFormat)
{
// since we only support TIME_FORMAT_MEDIA_TIME, we don't really
// offer any conversions.
if(pTargetFormat == 0 || *pTargetFormat == TIME_FORMAT_MEDIA_TIME) {
if(pSourceFormat == 0 || *pSourceFormat == TIME_FORMAT_MEDIA_TIME) {
*pTarget = Source;
return S_OK;
}
}
return E_INVALIDARG;
}
// --- input pin implementation --------------------------------
BridgeSinkInput::BridgeSinkInput(
BridgeSink* pFilter,
BridgeStream* pStream,
CCritSec* pLock,
HRESULT* phr,
LPCWSTR pName)
: CBaseInputPin(NAME("BridgeSinkInput"), pFilter, pLock, phr, pName),
m_pStream(pStream),
m_pRedirectedAlloc(NULL),
m_bConnected(false),
m_nDeliveryLocks(0),
m_bSendDTC(false),
m_bStoppedWhileConnected(false)
{
m_bAudio = !m_pStream->IsVideo();
m_hsemDelivery = CreateSemaphore(NULL, 1, 1, NULL);
if (!m_pStream->DiscardMode())
{
m_pRedirectedAlloc = new BridgeAllocator(this);
m_pRedirectedAlloc->AddRef();
}
}
BridgeSinkInput::~BridgeSinkInput()
{
if (m_pRedirectedAlloc)
{
m_pRedirectedAlloc->Release();
}
CloseHandle(m_hsemDelivery);
}
void
BridgeSinkInput::LockIncremental()
{
// if there are multiple calls to this on separate
// threads, there's a chance that the second one
// will be left blocked on the semaphore when he should be seeing the
// incremental indicator. To avoid this, timeout the semaphore and loop
for (;;)
{
{
CAutoLock lock(&m_csDelivery);
if (m_nDeliveryLocks > 0)
{
// lock is incremental -- can add to it
m_nDeliveryLocks++;
return;
}
}
// acquire exclusive lock
DWORD dw = WaitForSingleObject(DeliveryLock(), 100);
if (dw == WAIT_OBJECT_0)
{
break;
}
}
// now mark it as incremental
CAutoLock lock(&m_csDelivery);
m_nDeliveryLocks++;
}
// if incremental, decrease count and release semaphore if 0.
// if exclusive, release semaphore (count is 0)
void
BridgeSinkInput::Unlock()
{
CAutoLock lock(&m_csDelivery);
if (m_nDeliveryLocks > 0)
{
// incremental lock
m_nDeliveryLocks--;
if (m_nDeliveryLocks > 0)
{
// not idle yet
return;
}
}
ReleaseSemaphore(m_hsemDelivery, 1, NULL);
}
// CBaseInputPin overrides
STDMETHODIMP
BridgeSinkInput::Receive(IMediaSample *pSampleIn)
{
LOG((TEXT("Pin 0x%x receive 0x%x"), this, pSampleIn));
// check state
HRESULT hr = CBaseInputPin::Receive(pSampleIn);
if (hr == S_OK)
{
// if not connected, do nothing.
// For the "discard on not connected" option, this
// is the correct behaviour. For the suspend on not connected option,
// we should not get here since GetBuffer will suspend.
{ // restrict critsec -- don't hold over blocking call
CAutoLock lock(&m_csConnect);
if (!m_bConnected)
{
LOG((TEXT("Sink pin 0x%x disconnected: discarding 0x%x"), this, pSampleIn));
// remember that the segment is broken
Filter()->Discard();
// just ignore this sample
return S_OK;
}
}
// we must hold a lock during receive. If upstream is using the proxy alloc,
// then the lock is held by the proxy sample. If not, we should get a proxy sample
// just for the duration of Receive so it will hold the lock
IProxySamplePtr pProxy = pSampleIn;
IMediaSamplePtr pInner;
if (pProxy != NULL)
{
// already has proxy and lock -- extract inner
pProxy->GetInner(&pInner);
}
else
{
// make new proxy to hold lock
hr = S_OK;
pProxy = new ProxySample(this, &hr);
// we already have the inner
pInner = pSampleIn;
}
LOG((TEXT("Pin 0x%x outer 0x%x, inner 0x%x"), this, pSampleIn, pInner));
// if we stopped while connected, our times will be reset to 0
// so we must notify the source
if (m_bStoppedWhileConnected)
{
GetStream()->ResetOnStop();
m_bStoppedWhileConnected = false;
}
// before changing it, we must make a copy
IMediaSamplePtr pLocal = pInner;
hr = S_OK;
if (GetStream()->GetController()->LiveTiming())
{
// map to absolute clock time here
// (and back in source graph)
// depends on using a common clock.
REFERENCE_TIME tStart, tStop;
if (pLocal->GetTime(&tStart, &tStop) == S_OK)
{
REFERENCE_TIME tSTO = Filter()->STO();
tStart += tSTO;
tStop += tSTO;
pLocal->SetTime(&tStart, &tStop);
pLocal->SetMediaTime(NULL, NULL);
}
}
else
{
// if we are starting delivery after being disconnected,
// the timestamps should begin at 0
// -- handled in filter to ensure common adjustment for all streams
Filter()->AdjustTime(pLocal);
}
// check for media type change
AM_MEDIA_TYPE* pmt;
CMediaType mtFromUpstream;
bool bTypeChange = false;
if (pLocal->GetMediaType(&pmt) == S_OK)
{
CMediaType mt(*pmt);
DeleteMediaType(pmt);
// is this a new type?
CMediaType mtDownstream;
GetStream()->GetSelectedType(&mtDownstream);
if (mt != mtDownstream)
{
// must be upstream-originated
GetStream()->SetSelectedType(&mt);
mtFromUpstream = mt;
bTypeChange = true;
}
}
else if (pProxy->GetType(&mtFromUpstream) == S_OK)
{
LOG((TEXT("Using DTC from proxy")));
// type change was attached to sample in GetBuffer
// but then erased in upstream filter
//re-attach to inner sample
pLocal->SetMediaType(&mtFromUpstream);
CMediaType mtDownstream;
GetStream()->GetSelectedType(&mtDownstream);
if (mtFromUpstream != mtDownstream)
{
// must be upstream-originated
GetStream()->SetSelectedType(&mtFromUpstream);
bTypeChange = true;
}
}
else if (m_bSendDTC)
{
// the type of the input needs to be passed downstream.
LOG((TEXT("Type change sample lost -- setting on next sample")));
m_bSendDTC = false;
mtFromUpstream = m_mt;
bTypeChange = true;
pLocal->SetMediaType(&m_mt);
}
// if we are in "discard" mode, we are not using the
// same allocator, so we must copy here
if (m_bUsingProxyAllocator)
{
hr = GetStream()->Deliver(pLocal);
}
else
{
// need to copy. For audio this might mean a repeated copy
int cIn = pLocal->GetActualDataLength();
int cOffset = 0;
while (cOffset < cIn)
{
IMediaSamplePtr pOut;
if (m_pCopyAllocator == NULL)
{
return VFW_E_NO_ALLOCATOR;
}
hr = m_pCopyAllocator->GetBuffer(&pOut, NULL, NULL, 0);
if (SUCCEEDED(hr))
{
hr = CopySample(pLocal, pOut, cOffset, cIn - cOffset);
cOffset += pOut->GetActualDataLength();
}
if (SUCCEEDED(hr))
{
if (bTypeChange)
{
pOut->SetMediaType(&mtFromUpstream);
bTypeChange = false;
}
hr = GetStream()->Deliver(pOut == NULL? pLocal : pOut);
}
if (FAILED(hr))
{
return hr;
}
}
}
}
return hr;
}
// copy a portion of the input buffer to the output. Copy times and flags on first portion
// only.
HRESULT
BridgeSinkInput::CopySample(IMediaSample* pIn, IMediaSample* pOut, int cOffset, int cLength)
{
BYTE* pDest;
pOut->GetPointer(&pDest);
BYTE* pSrc;
pIn->GetPointer(&pSrc);
pSrc += cOffset;
long cOut = pOut->GetSize();
long cIn = pIn->GetActualDataLength();
cLength = min(cLength, cOut);
// ensure we copy whole samples if audio
if ((*m_mt.Type() == MEDIATYPE_Audio) &&
(*m_mt.FormatType() == FORMAT_WaveFormatEx))
{
WAVEFORMATEX* pwfx = (WAVEFORMATEX*)m_mt.Format();
cLength -= cLength % pwfx->nBlockAlign;
}
if ((cOffset + cLength) > cIn)
{
return VFW_E_BUFFER_OVERFLOW;
}
CopyMemory(pDest, pSrc, cLength);
pOut->SetActualDataLength(cLength);
// properties are set on first buffer only
if (cOffset == 0)
{
REFERENCE_TIME tStart, tEnd;
if (SUCCEEDED(pIn->GetTime(&tStart, &tEnd)))
{
pOut->SetTime(&tStart, &tEnd);
}
if (SUCCEEDED(pIn->GetMediaTime(&tStart, &tEnd)))
{
pOut->SetMediaTime(&tStart, &tEnd);
}
if (pIn->IsSyncPoint() == S_OK)
{
pOut->SetSyncPoint(true);
}
if (pIn->IsDiscontinuity() == S_OK)
{
pOut->SetDiscontinuity(true);
}
if (pIn->IsPreroll() == S_OK)
{
pOut->SetPreroll(true);
}
}
return S_OK;
}
STDMETHODIMP
BridgeSinkInput::EndOfStream(void)
{
HRESULT hr = Filter()->NotifyEvent(EC_COMPLETE, S_OK, NULL);
Filter()->OnEOS(m_bConnected);
return CBaseInputPin::EndOfStream();
}
HRESULT
BridgeSinkInput::CheckMediaType(const CMediaType* pmt)
{
// do we insist on the decoder being in the upstream segment?
if (GetStream()->AllowedTypes() == eUncompressed)
{
if (!IsUncompressed(pmt))
{
return VFW_E_TYPE_NOT_ACCEPTED;
}
} else if (GetStream()->AllowedTypes() == eMuxInputs)
{
if (!IsAllowedMuxInput(pmt))
{
return VFW_E_TYPE_NOT_ACCEPTED;
}
}
// check with bridge stream -- type is fixed once output
// stage has been built
return GetStream()->CanReceiveType(pmt);
}
HRESULT
BridgeSinkInput::GetMediaType(int iPosition, CMediaType* pmt)
{
UNREFERENCED_PARAMETER(iPosition);
UNREFERENCED_PARAMETER(pmt);
return VFW_S_NO_MORE_ITEMS;
}
HRESULT
BridgeSinkInput::SetMediaType(const CMediaType* pmt)
{
HRESULT hr = CBaseInputPin::SetMediaType(pmt);
if (SUCCEEDED(hr))
{
CAutoLock lock(&m_csConnect);
if (m_bConnected)
{
GetStream()->SetSelectedType(pmt);
}
}
return hr;
}
bool
BridgeSinkInput::IsUncompressed(const CMediaType* pmt)
{
if (m_bAudio)
{
if (*pmt->Type() != MEDIATYPE_Audio)
{
return false;
}
if (*pmt->FormatType() != FORMAT_WaveFormatEx)
{
return false;
}
WAVEFORMATEX* pwfx = (WAVEFORMATEX*)pmt->Format();
if (pwfx->wFormatTag != WAVE_FORMAT_PCM)
{
return false;
}
return true;
} else {
if (*pmt->Type() != MEDIATYPE_Video)
{
return false;
}
if (
(*pmt->Subtype() == MEDIASUBTYPE_ARGB32)||
(*pmt->Subtype() == MEDIASUBTYPE_RGB32) ||
(*pmt->Subtype() == MEDIASUBTYPE_RGB24) ||
(*pmt->Subtype() == MEDIASUBTYPE_YUY2) ||
(*pmt->Subtype() == MEDIASUBTYPE_UYVY) ||
(*pmt->Subtype() == MEDIASUBTYPE_Y41P) ||
(*pmt->Subtype() == MEDIASUBTYPE_RGB555) ||
(*pmt->Subtype() == MEDIASUBTYPE_RGB565) ||
(*pmt->Subtype() == MEDIASUBTYPE_RGB8)
)
{
return true;
}
}
return false;
}
bool
BridgeSinkInput::IsAllowedMuxInput(const CMediaType* pmt)
{
// the AVI Mux only accepts certain formats -- we
// must check for them at the sink.
if (*pmt->Type() == MEDIATYPE_Video)
{
//must be either VideoInfo or DvInfo
if (*pmt->FormatType() == FORMAT_VideoInfo)
{
// for VideoInfo, must have no target rect and no negative height
VIDEOINFOHEADER* pvi = (VIDEOINFOHEADER*)pmt->Format();
if ((pvi->bmiHeader.biHeight < 0) ||
(pvi->rcTarget.left != 0) ||
((pvi->rcTarget.right != 0) && (pvi->rcTarget.right != pvi->bmiHeader.biWidth)))
{
return false;
}
} else if (*pmt->FormatType() != FORMAT_DvInfo)
{
return false;
}
} else if (*pmt->Type() == MEDIATYPE_Audio)
{
// audio must be WaveFormatEx with a valid nBlockAlign
if (*pmt->FormatType() != FORMAT_WaveFormatEx)
{
return false;
}
WAVEFORMATEX* pwfx = (WAVEFORMATEX*)pmt->Format();
if (pwfx->nBlockAlign == 0)
{
return false;
}
} else {
return false;
}
return true;
}
STDMETHODIMP
BridgeSinkInput::GetAllocator(IMemAllocator **ppAllocator)
{
/// if not connected, should we discard?
HRESULT hr;
if (GetStream()->DiscardMode())
{
// yes -- so we must use a standard allocator
// (which will still work when not connected
hr = CBaseInputPin::GetAllocator(ppAllocator);
} else {
// prefer our allocator since this handles dynamic type changes
// as well as preventing copies
hr = m_pRedirectedAlloc->QueryInterface(IID_IMemAllocator, (void**)ppAllocator);
}
return hr;
}
STDMETHODIMP
BridgeSinkInput::NotifyAllocator(IMemAllocator * pAllocator, BOOL bReadOnly)
{
if (!GetStream()->DiscardMode())
{
// insist on our allocator
IUnknownPtr pOurs = m_pRedirectedAlloc;
IUnknownPtr pNotified = pAllocator;
if (pOurs == pNotified)
{
m_bUsingProxyAllocator = true;
}
else
{
m_bUsingProxyAllocator = false;
// for video, we must use the proxy alloc or we can't handle
// type switching.
// for audio, we could allow this, but we would need to add
// code in Receive, since currently we rely on the allocator blocking
// until connected -- with a foreign allocator, we would need to block in receive instead.
// This would be a benefit in some DV cases where the audio buffer size is an issue and
// hard to renegotiate between clips.
// error code is not quite ideal, but at least points at the offending object
return VFW_E_NO_ALLOCATOR;
}
}
else
{
m_bUsingProxyAllocator = false;
}
return CBaseInputPin::NotifyAllocator(pAllocator, bReadOnly);
}
STDMETHODIMP
BridgeSinkInput::BeginFlush()
{
LOG((TEXT("Pin 0x%x BeginFlush"), this));
HRESULT hr = CBaseInputPin::BeginFlush();
// allocator must fail without blocking while flushing - this is
// the same as decommit state
if (m_pRedirectedAlloc && m_bUsingProxyAllocator)
{
m_pRedirectedAlloc->Decommit();
}
// pass on to the downstream graph if connected
CAutoLock lock(&m_csConnect);
if (m_bConnected)
{
hr = GetStream()->BeginFlush();
}
return hr;
}
STDMETHODIMP
BridgeSinkInput::EndFlush()
{
LOG((TEXT("Pin 0x%x EndFlush"), this));
HRESULT hr = CBaseInputPin::EndFlush();
// reset end-of-stream if delivered
Filter()->ResetEOSCount();
// undo the Decommit done during BeginFlush
if (m_pRedirectedAlloc && m_bUsingProxyAllocator)
{
m_pRedirectedAlloc->Commit();
}
// pass on to the downstream graph if connected
CAutoLock lock(&m_csConnect);
if (m_bConnected)
{
hr = GetStream()->EndFlush();
}
return hr;
}
// we are now the selected source for the downstream
// graph.
HRESULT
BridgeSinkInput::MakeBridge(IMemAllocator* pAlloc)
{
LOG((TEXT("Pin 0x%x Bridge to alloc 0x%x"), this, pAlloc));
CAutoLock lock(&m_csConnect);
m_bStoppedWhileConnected = false;
m_bConnected = true;
HRESULT hr = S_OK;
if (m_bUsingProxyAllocator)
{
// the previous source graph or the renderer may have
// made a type change -- ensure this is on the first sample
// -- so we set it before enabling the GetBuffer
CMediaType mt;
GetStream()->GetSelectedType(&mt);
// is it compatible?
if (mt != m_mt)
{
// dynamic changes sent upstream with GetBuffer only work reliably with video
if (*m_mt.Type() == MEDIATYPE_Video)
{
hr = CanDeliverType(&mt);
if (hr == S_OK)
{
// sadly, many codecs do not check the size
// they are offered, and will claim to output anything
hr = BridgeStream::CheckMismatchedVideo(&mt, &m_mt);
}
} else {
hr = E_FAIL;
}
if (hr == S_OK)
{
// switch our source to this type by attaching at
// next GetBuffer
LOG((TEXT("Switching source to stream type")));
m_pRedirectedAlloc->ForceDTC(&mt);
} else if ((*m_mt.Type() == MEDIATYPE_Video))
{
// don't switch back to the previously connected type, or the VR might
// see an extended stride as part of the video. Instead, enumerate
// the preferred formats from the source and try those. However, stick to
// the same subtype.
hr = VFW_E_TYPE_NOT_ACCEPTED;
IEnumMediaTypesPtr pEnum;
GetConnected()->EnumMediaTypes(&pEnum);
AM_MEDIA_TYPE* pmt;
while(pEnum->Next(1, &pmt, NULL) == S_OK)
{
CMediaType mtEnum(*pmt);
DeleteMediaType(pmt);
if ((CanDeliverType(&mtEnum) == S_OK) &&
(*mtEnum.Subtype() == *m_mt.Subtype()) &&
GetStream()->CanSwitchTo(&mtEnum))
{
LOG((TEXT("ReceiveConnect to enumerated source type")));
m_pRedirectedAlloc->SwitchFormatTo(&mtEnum);
hr = S_OK;
break;
}
}
if (hr != S_OK)
{
LOG((TEXT("No suitable video type - failing bridge")));
return hr;
}
} else
{
// attempt a dynamic switch downstream to the format
// that our source is using
LOG((TEXT("Switching downstream to source type")));
m_pRedirectedAlloc->ForceDTC(&m_mt);
// the type change is attached to a buffer from our GetBuffer,
// and we need to pass it downstream, even if that sample is discarded
// or the mt is cleared. So we set a flag here indicating that
// we need to set the type onto the next incoming sample.
m_bSendDTC = true;
}
}
// redirect allocator
hr = m_pRedirectedAlloc->SetDownstreamAlloc(pAlloc);
} else {
m_pCopyAllocator = pAlloc;
}
return hr;
}
// we are now disconnected from downstream
HRESULT
BridgeSinkInput::DisconnectBridge()
{
LOG((TEXT("Pin 0x%x disconnect"), this));
if (m_pRedirectedAlloc && m_bUsingProxyAllocator)
{
m_pRedirectedAlloc->SetDownstreamAlloc(NULL);
}
CAutoLock lock(&m_csConnect);
// if we are in mid-flush, remember that the endflush will
// not be passed on
if (m_bFlushing && m_bConnected)
{
LOG((TEXT("Pin 0x%x disconnect when mid-flush"), this));
GetStream()->EndFlush();
}
m_bConnected = false;
m_bStoppedWhileConnected = false;
return S_OK;
}
HRESULT
BridgeSinkInput::GetBufferProps(long* pcBuffers, long* pcBytes)
{
// return whatever we have agreed, whether the bridge allocator or not
HRESULT hr = VFW_E_NO_ALLOCATOR;
if (m_pAllocator)
{
ALLOCATOR_PROPERTIES prop;
hr = m_pAllocator->GetProperties(&prop);
*pcBuffers = prop.cBuffers;
*pcBytes = prop.cbBuffer;
}
return hr;
}
HRESULT
BridgeSinkInput::CanDeliverType(const CMediaType* pmt)
{
// do we insist on the decoder being in the upstream segment?
if (GetStream()->AllowedTypes() == eUncompressed)
{
if (!IsUncompressed(pmt))
{
return VFW_E_TYPE_NOT_ACCEPTED;
}
} else if (GetStream()->AllowedTypes() == eMuxInputs)
{
if (!IsAllowedMuxInput(pmt))
{
return VFW_E_TYPE_NOT_ACCEPTED;
}
}
if (!IsConnected())
{
return VFW_E_NOT_CONNECTED;
}
// query accept on upstream output pin
return GetConnected()->QueryAccept(pmt);
}
HRESULT
BridgeSinkInput::EnumOutputType(int iPosition, CMediaType* pmt)
{
// enumerate output types on upstream pin
if (!IsConnected())
{
return VFW_E_NOT_CONNECTED;
}
IEnumMediaTypesPtr pEnum;
HRESULT hr = GetConnected()->EnumMediaTypes(&pEnum);
if (SUCCEEDED(hr))
{
pEnum->Skip(iPosition);
AM_MEDIA_TYPE* amt;
hr = pEnum->Next(1, &amt, NULL);
if (hr == S_OK)
{
*pmt = *amt;
DeleteMediaType(amt);
}
}
return hr;
}
HRESULT
BridgeSinkInput::Inactive()
{
if (Filter()->IsActive() && m_bConnected)
{
m_bStoppedWhileConnected = true;
}
return __super::Inactive();
}
// --------- Redirecting allocator implementation --------------------------
BridgeAllocator::BridgeAllocator(BridgeSinkInput* pPin)
: CUnknown(NAME("BridgeAllocator"), NULL),
m_pPin(pPin),
m_bForceDTC(false),
m_bSwitchConnection(false),
m_bCommitted(false),
m_evNonBlocking(true) // manual reset
{
ZeroMemory(&m_props, sizeof(m_props));
// while not committed, we just reject calls, not block
// (blocking is only when we are active, but not connected to
// the downstream graph)
m_evNonBlocking.Set();
}
STDMETHODIMP
BridgeAllocator::NonDelegatingQueryInterface(REFIID iid, void** ppv)
{
if (iid == IID_IMemAllocator)
{
return GetInterface((IMemAllocator*)this, ppv);
} else {
return CUnknown::NonDelegatingQueryInterface(iid, ppv);
}
}
STDMETHODIMP
BridgeAllocator::SetProperties(
ALLOCATOR_PROPERTIES* pRequest,
ALLOCATOR_PROPERTIES* pActual)
{
// requests are passed to the downstream allocator by
// the BridgeSourceOutput pin when the downstream graph
// is being built.
CAutoLock lock(&m_csAlloc);
m_props = *pRequest;
// for uncompressed video, the buffer size will change as the output type changes
// so we accept any properties
HRESULT hr = S_OK;
if (!m_pPin->GetStream()->IsVideo())
{
// for audio, we should tell the caller what buffers are actually in use and
// allow them to reject it.
long cBuffers, cBytes;
if (m_pPin->GetStream()->GetDownstreamBufferProps(&cBuffers, &cBytes))
{
m_props.cbBuffer = cBytes;
m_props.cBuffers = cBuffers;
if (cBytes < pRequest->cbBuffer)
{
hr = VFW_E_BUFFER_UNDERFLOW;
}
}
}
*pActual = m_props;
return hr;
}
STDMETHODIMP
BridgeAllocator::GetProperties(ALLOCATOR_PROPERTIES *pProps)
{
// it's probably best to pass on the actual props if possible
CAutoLock lock(&m_csAlloc);
HRESULT hr = S_OK;
if (m_pTarget == NULL)
{
*pProps = m_props;
} else {
hr = m_pTarget->GetProperties(pProps);
}
return hr;
}
STDMETHODIMP
BridgeAllocator::ReleaseBuffer(IMediaSample *pSample)
{
UNREFERENCED_PARAMETER(pSample);
// called via sample's pointer to originating allocator -- so
// our implementation will never be called.
return S_OK;
}
STDMETHODIMP
BridgeAllocator::GetBuffer(
IMediaSample **ppBuffer,
REFERENCE_TIME *pStart,
REFERENCE_TIME *pEnd,
DWORD dwFlags)
{
LOG((TEXT("GetBuffer on sink pin 0x%x"), m_pPin));
IProxySamplePtr pProxy;
// block until connected and committed
for(;;)
{
// wait on the event, then grab the locks in
// the right order. Then check that we are
// connected/committed, and if not, release the locks and try again
m_evNonBlocking.Wait();
// create a proxy -- locks the pin
HRESULT hr = S_OK;
pProxy = new ProxySample(m_pPin, &hr);
// target-alloc critsec
CAutoLock lock(&m_csAlloc);
// committed?
if (!m_bCommitted)
{
return VFW_E_NOT_COMMITTED;
}
// connected?
if (m_pTarget != NULL)
{
break;
}
pProxy = NULL;
}
HRESULT hr = S_OK;
if (m_bSwitchConnection)
{
hr = m_pPin->GetStream()->SwitchTo(&m_mtDTC);
if (SUCCEEDED(hr))
{
m_bForceDTC = true;
m_bSwitchConnection = false;
}
}
// call target allocator
// target cannot change while we hold the semaphore
IMediaSamplePtr pSample;
if (SUCCEEDED(hr))
{
hr = m_pTarget->GetBuffer(&pSample, pStart, pEnd, dwFlags);
}
// dynamic type changes?
if (SUCCEEDED(hr))
{
CAutoLock lock(&m_csAlloc);
// check for dynamic type change from downstream
AM_MEDIA_TYPE* pmt;
if (pSample->GetMediaType(&pmt) == S_OK)
{
CMediaType mt(*pmt);
DeleteMediaType(pmt);
// notify controller that this sample has a type change
// (the source will normally clear it before calling our Receive method).
// If we were actually processing the data within the sink, we would
// need to switch type when this exact sample reappears at the input
// (although by then the media type will have been removed from the sample).
// However, for our purposes, we can switch now.
m_pPin->SetMediaType(&mt);
} else if (m_bForceDTC)
{
// initiate a dynamic type change ourselves
pSample->SetMediaType(&m_mtDTC);
// attach to our proxy so that we can detect this type change
// on the way downstream even if the upstream filter erases it
pProxy->SetType(&m_mtDTC);
// if this is a switch to a new format, tell the pin & stream
m_pPin->SetMediaType(&m_mtDTC);
}
m_bForceDTC = false;
}
if (SUCCEEDED(hr))
{
pProxy->SetInner(pSample);
IMediaSamplePtr pOuter = pProxy;
*ppBuffer = pOuter.Detach();
}
if (hr != S_OK)
{
LOG((TEXT("GetBuffer on pin 0x%x returns 0x%x"), m_pPin, hr));
}
return hr;
}
STDMETHODIMP
BridgeAllocator::Commit()
{
// ensure that we block when active but disconnected
CAutoLock lock(&m_csAlloc);
m_bCommitted = true;
if (m_pTarget == NULL)
{
m_evNonBlocking.Reset();
}
LOG((TEXT("BridgeAlloc 0x%x commit, %s"), this, m_pTarget==NULL?TEXT("Disconnected"):TEXT("Connected")));
return S_OK;
}
STDMETHODIMP
BridgeAllocator::Decommit()
{
// ensure that we block when active but disconnected
// -- we are now inactive
CAutoLock lock(&m_csAlloc);
m_bCommitted = false;
m_evNonBlocking.Set();
LOG((TEXT("BridgeAlloc 0x%x decommit, %s"), this, m_pTarget==NULL?TEXT("Disconnected"):TEXT("Connected")));
return S_OK;
}
HRESULT
BridgeAllocator::SetDownstreamAlloc(IMemAllocator* pAlloc)
{
// lock cs *after* semaphore
CAutoLock lock(&m_csAlloc);
// target allocator -- could be null if disconnecting
m_pTarget = pAlloc;
// ensure non-blocking when connected or not active
if ((m_pTarget != NULL) || !m_bCommitted)
{
m_evNonBlocking.Set();
} else {
m_evNonBlocking.Reset();
}
return S_OK;
}
// -- sample proxy implementation ------------------
ProxySample::ProxySample(BridgeSinkInput* pPin, HRESULT* phr)
: CUnknown(NAME("ProxySample"), NULL, phr),
m_pPin(pPin),
m_bDTC(false)
{
// increment lock for each outstanding buffer
m_pPin->LockIncremental();
}
ProxySample::~ProxySample()
{
// release lock on deletion
m_pPin->Unlock();
}
STDMETHODIMP
ProxySample::NonDelegatingQueryInterface(REFIID iid, void** ppv)
{
if ((iid == IID_IMediaSample) || (iid == IID_IMediaSample2))
{
return GetInterface((IMediaSample2*)this, ppv);
}
else if (iid == __uuidof(IProxySample))
{
return GetInterface((IProxySample*)this, ppv);
}
else
{
return CUnknown::NonDelegatingQueryInterface(iid, ppv);
}
}
STDMETHODIMP
ProxySample::SetInner(IMediaSample* pSample)
{
m_pInner = pSample;
return S_OK;
}
STDMETHODIMP
ProxySample::GetInner(IMediaSample** ppSample)
{
*ppSample = m_pInner;
if (m_pInner != NULL)
{
m_pInner->AddRef();
return S_OK;
}
return S_FALSE;
}
STDMETHODIMP
ProxySample::ReleaseInner()
{
m_pInner = NULL;
return S_OK;
}
STDMETHODIMP
ProxySample::SetType(const CMediaType* pType)
{
m_mtDTC = *pType;
m_bDTC = true;
return S_OK;
}
STDMETHODIMP
ProxySample::GetType(CMediaType* pType)
{
if (m_bDTC)
{
*pType = m_mtDTC;
return S_OK;
}
return S_FALSE;
}
STDMETHODIMP
ProxySample::GetPointer(BYTE ** ppBuffer)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->GetPointer(ppBuffer);
}
STDMETHODIMP_(LONG)
ProxySample::GetSize(void)
{
if (m_pInner == NULL)
{
return 0;
}
return m_pInner->GetSize();
}
STDMETHODIMP
ProxySample::GetTime(
REFERENCE_TIME * pTimeStart, // put time here
REFERENCE_TIME * pTimeEnd
)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->GetTime(pTimeStart, pTimeEnd);
}
STDMETHODIMP
ProxySample::SetTime(
REFERENCE_TIME * pTimeStart, // put time here
REFERENCE_TIME * pTimeEnd
)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->SetTime(pTimeStart, pTimeEnd);
}
STDMETHODIMP
ProxySample::IsSyncPoint(void)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->IsSyncPoint();
}
STDMETHODIMP
ProxySample::SetSyncPoint(BOOL bIsSyncPoint)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->SetSyncPoint(bIsSyncPoint);
}
STDMETHODIMP
ProxySample::IsPreroll(void)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->IsPreroll();
}
STDMETHODIMP
ProxySample::SetPreroll(BOOL bIsPreroll)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->SetPreroll(bIsPreroll);
}
STDMETHODIMP_(LONG)
ProxySample::GetActualDataLength(void)
{
if (m_pInner == NULL)
{
return 0;
}
return m_pInner->GetActualDataLength();
}
STDMETHODIMP
ProxySample::SetActualDataLength(LONG lActual)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->SetActualDataLength(lActual);
}
STDMETHODIMP
ProxySample::GetMediaType(AM_MEDIA_TYPE **ppMediaType)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->GetMediaType(ppMediaType);
}
STDMETHODIMP
ProxySample::SetMediaType(AM_MEDIA_TYPE *pMediaType)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->SetMediaType(pMediaType);
}
STDMETHODIMP
ProxySample::IsDiscontinuity(void)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->IsDiscontinuity();
}
STDMETHODIMP
ProxySample::SetDiscontinuity(BOOL bDiscontinuity)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->SetDiscontinuity(bDiscontinuity);
}
STDMETHODIMP
ProxySample::GetMediaTime(
LONGLONG * pTimeStart,
LONGLONG * pTimeEnd
)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->GetMediaTime(pTimeStart, pTimeEnd);
}
STDMETHODIMP
ProxySample::SetMediaTime(
LONGLONG * pTimeStart,
LONGLONG * pTimeEnd
)
{
if (m_pInner == NULL)
{
return E_NOINTERFACE;
}
return m_pInner->SetMediaTime(pTimeStart, pTimeEnd);
}
STDMETHODIMP
ProxySample::GetProperties(
DWORD cbProperties,
BYTE * pbProperties
)
{
IMediaSample2Ptr p2 = m_pInner;
if (p2 == NULL)
{
return E_NOINTERFACE;
}
return p2->GetProperties(cbProperties, pbProperties);
}
STDMETHODIMP
ProxySample::SetProperties(
DWORD cbProperties,
const BYTE * pbProperties
)
{
IMediaSample2Ptr p2 = m_pInner;
if (p2 == NULL)
{
return E_NOINTERFACE;
}
return p2->SetProperties(cbProperties, pbProperties);
}
| 45,488 | 16,675 |
#include <iostream>
#include "rb.h"
#include <algorithm>
using namespace std;
struct temp {
int x;
int y;
bool operator()(const temp& lhs, const temp& rhs) { return lhs.y < rhs.y; }
friend std::ostream& operator<<(std::ostream& os, const temp& temp) {
os << temp.y;
return os;
}
};
int main(void)
{
RBTree<int> *tree = new RBTree<int>();
RBTree<int> tree1;
RBTree<struct temp, struct temp> *tree_user = new RBTree<struct temp, struct temp>();
#if 1 // tree creation -pointer
RBNode<int> *ny11 = new RBNode<int>(11);
RBNode<int> *ny3 = new RBNode<int>(3);
RBNode<int> *ny1 = new RBNode<int>(1);
RBNode<int> *ny7 = new RBNode<int>(7);
RBNode<int> *ny5 = new RBNode<int>(5);
RBNode<int> *ny8 = new RBNode<int>(8);
RBNode<int> *ny12 = new RBNode<int>(12);
RBNode<int> *ny15 = new RBNode<int>(15);
RBNode<int> *ny4 = new RBNode<int>(4);
RBTree<int>::Iterator it_11 = tree->insert(ny11);
RBTree<int>::Iterator it_3 = tree->insert(ny3);
RBTree<int>::Iterator it_1 = tree->insert(ny1);
RBTree<int>::Iterator it_7 = tree->insert(ny7);
RBTree<int>::Iterator it_5 = tree->insert(ny5);
RBTree<int>::Iterator it_8 = tree->insert(ny8);
RBTree<int>::Iterator it_12 = tree->insert(ny12);
RBTree<int>::Iterator it_15 = tree->insert(ny15);
RBTree<int>::Iterator it_4 = tree->insert(ny4);
tree->remove(8);
tree->remove(15);
tree->remove(7);
#endif
#if 0 // tree 1 creation - object
RBNode<int> *ny10_ = new RBNode<int>(10);
RBNode<int> *ny2_ = new RBNode<int>(2);
RBNode<int> *ny1_ = new RBNode<int>(1);
RBNode<int> *ny3_ = new RBNode<int>(3);
RBNode<int> *ny13_ = new RBNode<int>(13);
RBNode<int> *ny4_ = new RBNode<int>(4);
RBNode<int> *ny9_ = new RBNode<int>(9);
RBNode<int> *ny8_ = new RBNode<int>(8);
RBNode<int> *ny6_ = new RBNode<int>(6);
RBTree<int>::Iterator it_10_ = tree1.insert(ny10_);
RBTree<int>::Iterator it_2_ = tree1.insert(ny2_);
RBTree<int>::Iterator it_1_ = tree1.insert(ny1_);
RBTree<int>::Iterator it_3_ = tree1.insert(ny3_);
RBTree<int>::Iterator it_13_ = tree1.insert(ny13_);
RBTree<int>::Iterator it_4_ = tree1.insert(ny4_);
RBTree<int>::Iterator it_9_ = tree1.insert(ny9_);
RBTree<int>::Iterator it_8_ = tree1.insert(ny8_);
RBTree<int>::Iterator it_6_ = tree1.insert(ny6_);
#endif
#if 0 // user defined type tree creation
struct temp y1 = {5, 13}; // 5 < 13 T/F
struct temp y2 = {6, 12};
struct temp y3 = {7, 11};
struct temp y4 = {8, 10};
struct temp y5 = {9, 9};
struct temp y6 = {10, 8};
struct temp y7 = {11, 7};
struct temp y8 = {12, 6};
struct temp y9 = {13, 5};
RBNode<struct temp> *ny1_t = new RBNode<struct temp>(y1);
RBNode<struct temp> *ny2_t = new RBNode<struct temp>(y2);
RBNode<struct temp> *ny3_t = new RBNode<struct temp>(y3);
RBNode<struct temp> *ny4_t = new RBNode<struct temp>(y4);
RBNode<struct temp> *ny5_t = new RBNode<struct temp>(y5);
RBNode<struct temp> *ny6_t = new RBNode<struct temp>(y6);
RBNode<struct temp> *ny7_t = new RBNode<struct temp>(y7);
RBNode<struct temp> *ny8_t = new RBNode<struct temp>(y8);
RBNode<struct temp> *ny9_t = new RBNode<struct temp>(y9);
RBTree<struct temp,struct temp>::Iterator it_10_t = tree_user->insert(ny1_t);
RBTree<struct temp,struct temp>::Iterator it_2_t = tree_user->insert(ny2_t);
RBTree<struct temp,struct temp>::Iterator it_1_t = tree_user->insert(ny3_t);
RBTree<struct temp,struct temp>::Iterator it_3_t = tree_user->insert(ny4_t);
RBTree<struct temp,struct temp>::Iterator it_13_t = tree_user->insert(ny5_t);
RBTree<struct temp,struct temp>::Iterator it_4_t = tree_user->insert(ny6_t);
RBTree<struct temp,struct temp>::Iterator it_9_t = tree_user->insert(ny7_t);
RBTree<struct temp,struct temp>::Iterator it_8_t = tree_user->insert(ny8_t);
RBTree<struct temp,struct temp>::Iterator it_6_t = tree_user->insert(ny9_t);
cout << *tree_user;
#endif
#if 0 // pre post inc/dec
cout << it_11;
cout << --it_12;
cout << it_12--;
cout << it_12++;
cout << *tree;
#endif
#if 0 // search n delete
//cout << tree->search(it_3);
tree->remove(4);
tree->remove(3);
//cout << tree->search(it_3);
tree->remove(42);
//tree->delete_tree();
cout << *tree;
#endif
//copy and move functions
//cout << *tree1;
//cout << *tree;
//RBTree<int> *tree2 (tree); //copy ctr
//cout << *tree2;
//tree = tree1; //copy assignment
//cout << tree1;
//tree = move(tree1); //move assignment
//RBTree<int> tree2 = std::move(tree1); //move ctr // tree 2 dummy
//cout << tree2;
//cout << "--\n";
//cout << tree1;
#if 1
RBTree<int> *lb_tree = new RBTree<int>();
lb_tree->insert(5);
lb_tree->insert(5);
lb_tree->insert(5);
lb_tree->insert(7);
RBNode<int> temp = RBNode<int>(4);
RBTree<int>::Iterator it = lb_tree->insert(7);
RBTree<int>::Iterator it1 = lb_tree->insert(&temp);
RBTree<int>::Iterator it_start = lb_tree->begin();
RBTree<int>::Iterator it_end = lb_tree->end();
cout << "\n Tree: \n";
cout << *lb_tree;
cout << "\n Lower-Bound: \n";
cout << *lb_tree->lower_bound(5);
cout << "\n Upper-Bound: \n";
cout << *lb_tree->upper_bound(7);
// using generic find
cout << "\n\nUsing generic find. \n";
RBTree<int>::Iterator find_it = std::find(it_start, it_end, 7);
cout << find_it;
#endif
return 0;
} | 5,206 | 2,315 |
#include "ShaderUtils.h"
#include <cctype>
#include <sstream>
namespace IG {
std::string ShaderUtils::constructDevice(Target target)
{
std::stringstream stream;
switch (target) {
case Target::AVX:
stream << "let device = make_avx_device();";
break;
case Target::AVX2:
stream << "let device = make_avx2_device();";
break;
case Target::AVX512:
stream << "let device = make_avx512_device();";
break;
case Target::SSE42:
stream << "let device = make_sse42_device();";
break;
case Target::ASIMD:
stream << "let device = make_asimd_device();";
break;
case Target::NVVM:
stream << "let device = make_nvvm_device(settings.device);";
break;
case Target::AMDGPU:
stream << "let device = make_amdgpu_device(settings.device);";
break;
default:
stream << "let device = make_cpu_default_device();";
break;
}
return stream.str();
}
std::string ShaderUtils::generateDatabase()
{
std::stringstream stream;
stream << " let dtb = device.load_scene_database();" << std::endl
<< " let shapes = device.load_shape_table(dtb.shapes);" << std::endl
<< " let entities = device.load_entity_table(dtb.entities);" << std::endl;
return stream.str();
}
std::string ShaderUtils::generateSceneInfoInline(const LoaderContext& ctx)
{
std::stringstream stream;
stream << "SceneInfo { num_entities = " << ctx.Environment.EntityIDs.size() << " }";
return stream.str();
}
std::string ShaderUtils::escapeIdentifier(const std::string& name)
{
IG_ASSERT(!name.empty(), "Given string should not be empty");
std::string copy = name;
if (!std::isalpha(copy[0])) {
copy = "_" + copy;
}
for (size_t i = 1; i < copy.size(); ++i) {
char& c = copy[i];
if (!std::isalnum(c))
c = '_';
}
return copy;
}
std::string ShaderUtils::inlineVector(const Vector3f& pos)
{
std::stringstream stream;
stream << "make_vec3(" << pos.x() << ", " << pos.y() << ", " << pos.z() << ")";
return stream.str();
}
std::string ShaderUtils::inlineColor(const Vector3f& color)
{
std::stringstream stream;
stream << "make_color(" << color.x() << ", " << color.y() << ", " << color.z() << ")";
return stream.str();
}
} // namespace IG | 2,387 | 795 |
/*
* Fast Positive Tables (libfpta), aka Позитивные Таблицы.
* Copyright 2016-2020 Leonid Yuriev <leo@yuriev.ru>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "fpta_test.h"
#include "keygen.hpp"
/* Кол-во проверочных точек в диапазонах значений индексируемых типов.
*
* Значение не может быть больше чем 65536, так как это предел кол-ва
* уникальных значений для fptu_uint16.
*
* Использовать тут большие значения смысла нет. Время работы тестов
* растет примерно линейно (чуть быстрее), тогда как вероятность
* проявления каких-либо ошибок растет в лучшем случае как Log(NNN),
* а скорее даже как SquareRoot(Log(NNN)).
*/
#ifdef FPTA_CURSOR_UT_LONG
static cxx11_constexp_varr int NNN = 65521; // около 1-2 минуты в /dev/shm/
#else
static cxx11_constexpr_var int NNN = 509; // менее секунды в /dev/shm/
#endif
static const char testdb_name[] = TEST_DB_DIR "ut_cursor_primary.fpta";
static const char testdb_name_lck[] =
TEST_DB_DIR "ut_cursor_primary.fpta" MDBX_LOCK_SUFFIX;
class CursorPrimary
: public ::testing::TestWithParam<GTEST_TUPLE_NAMESPACE_::tuple<
fptu_type, fpta_index_type, fpta_cursor_options>> {
public:
fptu_type type;
fpta_index_type index;
fpta_cursor_options ordering;
bool valid_index_ops;
bool valid_cursor_ops;
bool skipped;
scoped_db_guard db_quard;
scoped_txn_guard txn_guard;
scoped_cursor_guard cursor_guard;
std::string pk_col_name;
fpta_name table, col_pk, col_order, col_dup_id, col_t1ha;
static cxx11_constexpr_var int n_dups = 5;
int n_records;
std::unordered_map<int, int> reorder;
static int mesh(int n) { return (int)((163 + (unsigned)n * 42101) % NNN); }
void CheckPosition(int linear, int dup_id, int expected_n_dups = 0,
bool check_dup_id = true) {
if (linear < 0) {
/* для удобства и выразительности теста linear = -1 здесь
* означает последнюю запись, -2 = предпоследнюю и т.д. */
linear += (int)reorder.size();
}
if (dup_id < 0) {
/* для удобства и выразительности теста dup_id = -1 здесь
* означает последний дубликат, -2 = предпоследний и т.д. */
dup_id += n_dups;
}
if (expected_n_dups == 0) {
/* для краткости теста expected_n_dups = 0 здесь означает значение
* по-умолчанию, когда строки-дубликаты не удаляются в ходе теста */
expected_n_dups = fpta_index_is_unique(index) ? 1 : n_dups;
}
SCOPED_TRACE("linear-order " + std::to_string(linear) + " [0..." +
std::to_string(reorder.size() - 1) + "], linear-dup " +
(check_dup_id ? std::to_string(dup_id) : "any"));
ASSERT_EQ(1u, reorder.count(linear));
const auto expected_order = reorder.at(linear);
/* Следует пояснить (в том числе напомнить себе), почему порядок
* следования строк-дубликатов (с одинаковым значением PK) здесь
* совпадает с dup_id:
* - При формировании строк-дубликатов, их кортежи полностью совпадают,
* за исключением поля dup_id. При этом dup_id отличается только
* одним байтом.
* - В случае primary-индекса данные, соответствующие одному значению
* ключа, сортируются при помощи компаратора fptu_cmp_tuples(), что
* формирует порядок по возрастанию dup_id. Однако, даже при
* сравнении посредством memcmp(), различие только в одном байте
* также сформирует порядок по возрастанию dup_id.
*
* Таким образом, физический порядок строк-дубликатов всегда по
* возрастанию dup_id (причем нет видимых причин это как-либо менять).
*
* --------------------------------------------------------------------
*
* Далее, для курсора с обратным порядком сортировки (descending)
* видимый порядок строк будет изменен на обратный, включая порядок
* строк-дубликатов. Предполагается что такая симметричность будет
* более ожидаема и удобна, нежели если порядок дубликатов
* сохранится (не будет обратным).
*
* Соответственно ниже для descending-курсора выполняется "переворот"
* контрольного номера дубликата. */
const int expected_dup_id = fpta_index_is_unique(index) ? 42
: fpta_cursor_is_descending(ordering)
? n_dups - (dup_id + 1)
: dup_id;
SCOPED_TRACE("logical-order " + std::to_string(expected_order) + " [" +
std::to_string(0) + "..." + std::to_string(NNN) +
"), logical-dup " +
(check_dup_id ? std::to_string(expected_dup_id) : "any"));
ASSERT_EQ(FPTA_OK, fpta_cursor_eof(cursor_guard.get()));
fptu_ro tuple;
ASSERT_EQ(FPTA_OK, fpta_cursor_get(cursor_guard.get(), &tuple));
ASSERT_STREQ(nullptr, fptu::check(tuple));
int error;
fpta_value key;
ASSERT_EQ(FPTA_OK, fpta_cursor_key(cursor_guard.get(), &key));
SCOPED_TRACE("key: " + std::to_string(key.type) + ", length " +
std::to_string(key.binary_length));
auto tuple_order = (int)fptu_get_sint(tuple, col_order.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
ASSERT_EQ(expected_order, tuple_order);
auto tuple_checksum = fptu_get_uint(tuple, col_t1ha.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
auto checksum = order_checksum(tuple_order, type, index).uint;
ASSERT_EQ(checksum, tuple_checksum);
auto tuple_dup_id =
(int)fptu_get_uint(tuple, col_dup_id.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
if (check_dup_id || fpta_index_is_unique(index)) {
EXPECT_EQ(expected_dup_id, tuple_dup_id);
}
size_t dups = 100500;
ASSERT_EQ(FPTA_OK, fpta_cursor_dups(cursor_guard.get(), &dups));
ASSERT_EQ(expected_n_dups, (int)dups);
}
virtual void Fill() {
fptu_rw *row = fptu_alloc(4, fpta_max_keylen * 2 + 4 + 4);
ASSERT_NE(nullptr, row);
ASSERT_STREQ(nullptr, fptu::check(row));
fpta_txn *const txn = txn_guard.get();
any_keygen keygen(type, index);
n_records = 0;
for (int linear = 0; linear < NNN; ++linear) {
int order = mesh(linear);
SCOPED_TRACE("order " + std::to_string(order));
fpta_value value_pk = keygen.make(order, NNN);
if (value_pk.type == fpta_end)
break;
if (value_pk.type == fpta_begin)
continue;
// теперь формируем кортеж
ASSERT_EQ(FPTU_OK, fptu_clear(row));
ASSERT_STREQ(nullptr, fptu::check(row));
ASSERT_EQ(FPTA_OK,
fpta_upsert_column(row, &col_order, fpta_value_sint(order)));
ASSERT_EQ(FPTA_OK, fpta_upsert_column(row, &col_pk, value_pk));
// t1ha как "checksum" для order
ASSERT_EQ(FPTA_OK,
fpta_upsert_column(row, &col_t1ha,
order_checksum(order, type, index)));
if (fpta_index_is_unique(index)) {
// вставляем одну запись с dup_id = 42
ASSERT_EQ(FPTA_OK,
fpta_upsert_column(row, &col_dup_id, fpta_value_uint(42)));
ASSERT_EQ(FPTA_OK,
fpta_insert_row(txn, &table, fptu_take_noshrink(row)));
++n_records;
} else {
for (int dup_id = 0; dup_id < n_dups; ++dup_id) {
ASSERT_EQ(FPTA_OK, fpta_upsert_column(row, &col_dup_id,
fpta_value_sint(dup_id)));
ASSERT_EQ(FPTA_OK,
fpta_insert_row(txn, &table, fptu_take_noshrink(row)));
++n_records;
}
}
}
// разрушаем кортеж
ASSERT_STREQ(nullptr, fptu::check(row));
free(row);
}
virtual void SetUp() {
// нужно простое число, иначе сломается переупорядочивание
ASSERT_TRUE(isPrime(NNN));
// иначе не сможем проверить fptu_uint16
ASSERT_GE(65535, NNN);
type = GTEST_TUPLE_NAMESPACE_::get<0>(GetParam());
index = GTEST_TUPLE_NAMESPACE_::get<1>(GetParam());
ordering = GTEST_TUPLE_NAMESPACE_::get<2>(GetParam());
valid_index_ops = is_valid4primary(type, index);
valid_cursor_ops = is_valid4cursor(index, ordering);
SCOPED_TRACE(
"type " + std::to_string(type) + ", index " + std::to_string(index) +
(valid_index_ops ? ", (valid index case)" : ", (invalid index case)"));
SCOPED_TRACE("ordering " + std::to_string(ordering) + ", index " +
std::to_string(index) +
(valid_cursor_ops ? ", (valid cursor case)"
: ", (invalid cursor case)"));
skipped = GTEST_IS_EXECUTION_TIMEOUT();
if (skipped)
return;
// инициализируем идентификаторы колонок
ASSERT_EQ(FPTA_OK, fpta_table_init(&table, "table"));
pk_col_name = "pk_" + std::to_string(type);
ASSERT_EQ(FPTA_OK, fpta_column_init(&table, &col_pk, pk_col_name.c_str()));
ASSERT_EQ(FPTA_OK, fpta_column_init(&table, &col_order, "order"));
ASSERT_EQ(FPTA_OK, fpta_column_init(&table, &col_dup_id, "dup_id"));
ASSERT_EQ(FPTA_OK, fpta_column_init(&table, &col_t1ha, "t1ha"));
// создаем четыре колонки: pk, order, t1ha и dup_id
fpta_column_set def;
fpta_column_set_init(&def);
if (!valid_index_ops) {
EXPECT_NE(FPTA_OK,
fpta_column_describe(pk_col_name.c_str(), type, index, &def));
EXPECT_EQ(FPTA_OK, fpta_column_describe("order", fptu_int32,
fpta_index_none, &def));
ASSERT_NE(FPTA_OK, fpta_column_set_validate(&def));
// разрушаем описание таблицы
EXPECT_EQ(FPTA_OK, fpta_column_set_destroy(&def));
EXPECT_NE(FPTA_OK, fpta_column_set_validate(&def));
return;
}
EXPECT_EQ(FPTA_OK,
fpta_column_describe(pk_col_name.c_str(), type, index, &def));
EXPECT_EQ(FPTA_OK,
fpta_column_describe("order", fptu_int32, fpta_index_none, &def));
EXPECT_EQ(FPTA_OK, fpta_column_describe("dup_id", fptu_uint16,
fpta_noindex_nullable, &def));
EXPECT_EQ(FPTA_OK,
fpta_column_describe("t1ha", fptu_uint64, fpta_index_none, &def));
ASSERT_EQ(FPTA_OK, fpta_column_set_validate(&def));
// чистим
if (REMOVE_FILE(testdb_name) != 0) {
ASSERT_EQ(ENOENT, errno);
}
if (REMOVE_FILE(testdb_name_lck) != 0) {
ASSERT_EQ(ENOENT, errno);
}
#ifdef FPTA_CURSOR_UT_LONG
// пытаемся обойтись меньшей базой,
// но для строк потребуется больше места
unsigned megabytes = 32;
if (type > fptu_96)
megabytes = 56;
if (type > fptu_256)
megabytes = 64;
#else
unsigned megabytes = 1;
#endif
/* В пике нужно примерно вдвое больше места, так как один из тестов
* будет выполнять удаление до половины строк в случайном порядке,
* и в результате может обновить почти каждую страницу БД. */
megabytes += megabytes;
fpta_db *db = nullptr;
ASSERT_EQ(FPTA_OK, test_db_open(testdb_name, fpta_weak, fpta_regime_default,
megabytes, true, &db));
ASSERT_NE(nullptr, db);
db_quard.reset(db);
// создаем таблицу
fpta_txn *txn = nullptr;
EXPECT_EQ(FPTA_OK, fpta_transaction_begin(db, fpta_schema, &txn));
ASSERT_NE(nullptr, txn);
txn_guard.reset(txn);
ASSERT_EQ(FPTA_OK, fpta_table_create(txn, "table", &def));
ASSERT_EQ(FPTA_OK, fpta_transaction_end(txn_guard.release(), false));
txn = nullptr;
// разрушаем описание таблицы
EXPECT_EQ(FPTA_OK, fpta_column_set_destroy(&def));
EXPECT_NE(FPTA_OK, fpta_column_set_validate(&def));
/* Для полноты тесты переоткрываем базу. В этом нет явной необходимости,
* но только так можно проверить работу некоторых механизмов.
*
* В частности:
* - внутри движка создание таблицы одновременно приводит к открытию её
* dbi-хендла, с размещением его во внутренних структурах.
* - причем этот хендл будет жив до закрытии всей базы, либо до удаления
* таблицы.
* - поэтому для проверки кода открывающего существующую таблицы
* необходимо закрыть и повторно открыть всю базу.
*/
// закрываем базу
ASSERT_EQ(FPTA_SUCCESS, fpta_db_close(db_quard.release()));
db = nullptr;
// открываем заново
ASSERT_EQ(FPTA_OK, test_db_open(testdb_name, fpta_weak, fpta_regime_default,
megabytes, false, &db));
ASSERT_NE(nullptr, db);
db_quard.reset(db);
//------------------------------------------------------------------------
// начинаем транзакцию записи
EXPECT_EQ(FPTA_OK, fpta_transaction_begin(db, fpta_write, &txn));
ASSERT_NE(nullptr, txn);
txn_guard.reset(txn);
// связываем идентификаторы с ранее созданной схемой
ASSERT_EQ(FPTA_OK, fpta_name_refresh_couple(txn, &table, &col_pk));
ASSERT_EQ(FPTA_OK, fpta_name_refresh(txn, &col_order));
ASSERT_EQ(FPTA_OK, fpta_name_refresh(txn, &col_dup_id));
ASSERT_EQ(FPTA_OK, fpta_name_refresh(txn, &col_t1ha));
ASSERT_NO_FATAL_FAILURE(Fill());
// завершаем транзакцию
ASSERT_EQ(FPTA_OK, fpta_transaction_end(txn_guard.release(), false));
txn = nullptr;
//------------------------------------------------------------------------
// начинаем транзакцию чтения
EXPECT_EQ(FPTA_OK, fpta_transaction_begin(db, fpta_read, &txn));
ASSERT_NE(nullptr, txn);
txn_guard.reset(txn);
fpta_cursor *cursor;
if (valid_cursor_ops) {
EXPECT_EQ(FPTA_OK,
fpta_cursor_open(txn, &col_pk, fpta_value_begin(),
fpta_value_end(), nullptr, ordering, &cursor));
ASSERT_NE(nullptr, cursor);
cursor_guard.reset(cursor);
} else {
EXPECT_EQ(FPTA_NO_INDEX,
fpta_cursor_open(txn, &col_pk, fpta_value_begin(),
fpta_value_end(), nullptr, ordering, &cursor));
cursor_guard.reset(cursor);
ASSERT_EQ(nullptr, cursor);
return;
}
// формируем линейную карту, чтобы проще проверять переходы
reorder.clear();
reorder.reserve(NNN);
int prev_order = -1;
for (int linear = 0; fpta_cursor_eof(cursor) == FPTA_OK; ++linear) {
fptu_ro tuple;
EXPECT_EQ(FPTA_OK, fpta_cursor_get(cursor_guard.get(), &tuple));
ASSERT_STREQ(nullptr, fptu::check(tuple));
int error;
auto tuple_order =
(int)fptu_get_sint(tuple, col_order.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
auto tuple_checksum = fptu_get_uint(tuple, col_t1ha.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
auto checksum = order_checksum(tuple_order, type, index).uint;
ASSERT_EQ(checksum, tuple_checksum);
reorder[linear] = tuple_order;
error = fpta_cursor_move(cursor, fpta_key_next);
if (error == FPTA_NODATA)
break;
ASSERT_EQ(FPTA_SUCCESS, error);
// проверяем упорядоченность
if (fpta_cursor_is_ordered(ordering) && linear > 0) {
if (fpta_cursor_is_ascending(ordering)) {
ASSERT_LE(prev_order, tuple_order);
} else {
ASSERT_GE(prev_order, tuple_order);
}
}
prev_order = tuple_order;
}
ASSERT_EQ(NNN, (int)reorder.size());
}
virtual void TearDown() {
if (skipped)
return;
// разрушаем привязанные идентификаторы
fpta_name_destroy(&table);
fpta_name_destroy(&col_pk);
fpta_name_destroy(&col_order);
fpta_name_destroy(&col_dup_id);
fpta_name_destroy(&col_t1ha);
// закрываем курсор и завершаем транзакцию
if (cursor_guard) {
EXPECT_EQ(FPTA_OK, fpta_cursor_close(cursor_guard.release()));
}
if (txn_guard) {
ASSERT_EQ(FPTA_OK, fpta_transaction_end(txn_guard.release(), true));
}
if (db_quard) {
// закрываем и удаляем базу
ASSERT_EQ(FPTA_SUCCESS, fpta_db_close(db_quard.release()));
ASSERT_TRUE(REMOVE_FILE(testdb_name) == 0);
ASSERT_TRUE(REMOVE_FILE(testdb_name_lck) == 0);
}
}
};
cxx11_constexpr_var int CursorPrimary::n_dups;
TEST_P(CursorPrimary, basicMoves) {
/* Проверка базовых перемещений курсора по первичному (primary) индексу.
*
* Сценарий (общий для всех типов полей и всех видов первичных индексов):
* 1. Создается тестовая база с одной таблицей, в которой четыре колонки:
* - "col_pk" (primary key) с типом, для которого производится
* тестирование работы индекса.
* - Колонка "order", в которую записывается контрольный (ожидаемый)
* порядковый номер следования строки, при сортировке по col_pk и
* проверяемому виду индекса.
* - Колонка "dup_id", которая используется для идентификации
* дубликатов индексов допускающих не-уникальные ключи.
* - Колонка "t1ha", в которую записывается "контрольная сумма" от
* ожидаемого порядка строки, типа PK и вида индекса.
* Принципиальной необходимости в этой колонке нет, она используется
* как "утяжелитель", а также для дополнительного контроля.
*
* 2. Для валидных комбинаций вида индекса и типа данных col_pk таблица
* заполняется строками, значение col_pk в которых генерируется
* соответствующим генератором значений:
* - Сами генераторы проверяются в одном из тестов 0corny.
* - Для индексов без уникальности для каждого ключа вставляется
* 5 строк с разным dup_id.
*
* 3. Перебираются все комбинации индексов, типов колонок и видов курсора.
* Для НЕ валидных комбинаций контролируются коды ошибок.
*
* 4. Для валидных комбинаций индекса и типа курсора, после заполнения
* в отдельной транзакции формируется "карта" верификации перемещений:
* - "карта" строится как неупорядоченное отображение линейных номеров
* строк в порядке просмотра через курсор, на ожидаемые (контрольные)
* значения колонки "order".
* - при построении "карты" все строки читаются последовательно через
* проверяемый курсор.
* - для построенной "карты" проверяется размер (что прочитали все
* строки и только по одному разу) и соответствия порядка строк
* типу курсора (возрастание/убывание).
*
* 5. После формирования "карты" верификации перемещений выполняется ряд
* базовых перемещений курсора:
* - переход к первой/последней строке.
* - попытки перейти за последнюю и за первую строки.
* - переход в начало с отступлением к концу.
* - переход к концу с отступление к началу.
* - при каждом перемещении проверяется корректность кода ошибки,
* соответствие текущей строки ожидаемому порядку, включая
* содержимое строки и номера дубликата.
*
* 6. Завершаются операции и освобождаются ресурсы.
*/
if (!valid_index_ops || !valid_cursor_ops || skipped)
return;
SCOPED_TRACE("type " + std::to_string(type) + ", index " +
std::to_string(index) +
(valid_index_ops ? ", (valid case)" : ", (invalid case)"));
SCOPED_TRACE(
"ordering " + std::to_string(ordering) + ", index " +
std::to_string(index) +
(valid_cursor_ops ? ", (valid cursor case)" : ", (invalid cursor case)"));
ASSERT_LT(5, n_records);
fpta_cursor *const cursor = cursor_guard.get();
ASSERT_NE(nullptr, cursor);
// переходим туда-сюда и к первой строке
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_first));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_last));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_first));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
// пробуем уйти дальше последней строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_last));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_next));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_last));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_first));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
// пробуем выйти за первую строку
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_first));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_prev));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_last));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_first));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
// идем в конец и проверяем назад/вперед
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_last));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_next));
// идем в начало и проверяем назад/вперед
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_first));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, -1));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, -1));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_prev));
}
//----------------------------------------------------------------------------
/* Другое имя класса требуется для инстанцирования другого (меньшего)
* набора комбинаций в INSTANTIATE_TEST_SUITE_P. */
class CursorPrimaryDups : public CursorPrimary {};
TEST_P(CursorPrimaryDups, dupMoves) {
/* Проверка перемещений курсора по дубликатами в первичном (primary)
* индексе.
*
* Сценарий (общий для всех типов полей и всех видов первичных индексов):
* 1. Создается тестовая база с одной таблицей, в которой четыре колонки:
* - "col_pk" (primary key) с типом, для которого производится
* тестирование работы индекса.
* - Колонка "order", в которую записывается контрольный (ожидаемый)
* порядковый номер следования строки, при сортировке по col_pk и
* проверяемому виду индекса.
* - Колонка "dup_id", которая используется для нумерации дубликатов.
* - Колонка "t1ha", в которую записывается "контрольная сумма" от
* ожидаемого порядка строки, типа PK и вида индекса. Принципиальной
* необходимости в этой колонке нет, она используется как
* "утяжелитель", а также для дополнительного контроля.
*
* 2. Для валидных комбинаций вида индекса и типа данных col_pk таблица
* заполняется строками, значение PK в которых генерируется
* соответствующим генератором значений:
* - Сами генераторы проверяются в одном из тестов 0corny.
* - Для каждого значения ключа вставляется 5 строк с разным dup_id.
* - FIXME: Дополнительно, для тестирования межстраничных переходов,
* генерируется длинная серия повторов, которая более чем в три раза
* превышает размер страницы БД.
*
* 3. Перебираются все комбинации индексов, типов колонок и видов курсора.
* Для НЕ валидных комбинаций контролируются коды ошибок.
*
* 4. Для валидных комбинаций индекса и типа курсора, после заполнения
* в отдельной транзакции формируется "карта" верификации перемещений:
* - "карта" строится как неупорядоченное отображение линейных номеров
* строк в порядке просмотра через курсор, на ожидаемые (контрольные)
* значения колонки "order".
* - при построении "карты" все строки читаются последовательно через
* проверяемый курсор.
* - для построенной "карты" проверяется размер (что прочитали все
* строки и только по одному разу) и соответствия порядка строк
* типу курсора (возрастание/убывание).
*
* 5. После формирования "карты" верификации перемещений выполняется ряд
* базовых перемещений курсора по дубликатам:
* - переход к первой/последней строке,
* к первому и последнему дубликату.
* - попытки перейти за последнюю и за первую строки,
* за первый/последний дубликат.
* - переход в начало с отступлением к концу.
* - переход к концу с отступление к началу.
* - при каждом перемещении проверяется корректность кода ошибки,
* соответствие текущей строки ожидаемому порядку, включая
* содержимое строки и номера дубликата.
*
* 6. Завершаются операции и освобождаются ресурсы.
*/
if (!valid_index_ops || !valid_cursor_ops || skipped ||
fpta_index_is_unique(index))
return;
SCOPED_TRACE("type " + std::to_string(type) + ", index " +
std::to_string(index) +
(valid_index_ops ? ", (valid case)" : ", (invalid case)"));
SCOPED_TRACE(
"ordering " + std::to_string(ordering) + ", index " +
std::to_string(index) +
(valid_cursor_ops ? ", (valid cursor case)" : ", (invalid cursor case)"));
ASSERT_LT(5, n_records);
fpta_cursor *const cursor = cursor_guard.get();
ASSERT_NE(nullptr, cursor);
/* переходим туда-сюда и к первой строке, такие переходы уже проверялись
* в предыдущем тесте, здесь же для проверки жизнеспособности курсора. */
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_first));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_last));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_first));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
// к последнему, затем к первому дубликату первой строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_last));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_first));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
// вперед по дубликатам первой строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 4));
// пробуем выйти за последний дубликат
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 4));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 4));
// назад по дубликатам первой строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
// пробуем выйти за первый дубликат
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
// вперед в обход дубликатов, ко второй строке, затем к третьей и четвертой
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(3, 0));
// назад в обход дубликатов, до первой строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, -1));
// пробуем выйти за первую строку
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
// последовательно вперед от начала по каждому дубликату
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(3, 0));
// последовательно назад к началу по каждому дубликату
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(2, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(1, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(0, 0));
// пробуем выйти за первую строку
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_prev));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_prev));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
//--------------------------------------------------------------------------
// к последней строке
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_last));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
// к первому, затем к последнему дубликату последней строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_first));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_last));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
// назад по дубликатам последней строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
// пробуем выйти за первый дубликат
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
// вперед по дубликатам первой строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 4));
// пробуем выйти за последний дубликат
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_dup_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, -1));
// назад в обход дубликатов, к предпоследней строке,
// затем к пред-предпоследней...
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, -1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-4, -1));
// вперед в обход дубликатов, до последней строки
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
// пробуем выйти за первую строку
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_key_next));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
// последовательно назад от конца по каждому дубликату
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 0));
// последовательно вперед до конца по каждому дубликату
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-3, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-2, 4));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 0));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 1));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 2));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 3));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_next));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 4));
// пробуем выйти за последнюю строку
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_next));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_move(cursor, fpta_next));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_prev));
ASSERT_NO_FATAL_FAILURE(CheckPosition(-1, 4));
}
//----------------------------------------------------------------------------
TEST_P(CursorPrimary, locate_and_delele) {
/* Проверка позиционирования курсора по первичному (primary) индексу.
*
* Сценарий (общий для всех типов полей и всех видов первичных индексов):
* 1. Создается тестовая база с одной таблицей, в которой четыре колонки:
* - "col_pk" (primary key) с типом, для которого производится
* тестирование работы индекса.
* - Колонка "order", в которую записывается контрольный (ожидаемый)
* порядковый номер следования строки, при сортировке по col_pk и
* проверяемому виду индекса.
* - Колонка "dup_id", которая используется для идентификации
* дубликатов индексов допускающих не-уникальные ключи.
* - Колонка "t1ha", в которую записывается "контрольная сумма" от
* ожидаемого порядка строки, типа PK и вида индекса.
* Принципиальной необходимости в этой колонке нет, она используется
* как "утяжелитель", а также для дополнительного контроля.
*
* 2. Для валидных комбинаций вида индекса и типа данных col_pk таблица
* заполняется строками, значение col_pk в которых генерируется
* соответствующим генератором значений:
* - Сами генераторы проверяются в одном из тестов 0corny.
* - Для индексов без уникальности для каждого ключа вставляется
* 5 строк с разным dup_id.
*
* 3. Перебираются все комбинации индексов, типов колонок и видов курсора.
* Для НЕ валидных комбинаций контролируются коды ошибок.
*
* 4. Для валидных комбинаций индекса и типа курсора, после заполнения
* в отдельной транзакции формируется "карта" верификации перемещений:
* - "карта" строится как неупорядоченное отображение линейных номеров
* строк в порядке просмотра через курсор, на ожидаемые (контрольные)
* значения колонки "order".
* - при построении "карты" все строки читаются последовательно через
* проверяемый курсор.
* - для построенной "карты" проверяется размер (что прочитали все
* строки и только по одному разу) и соответствия порядка строк
* типу курсора (возрастание/убывание).
*
* 5. После формирования "карты" выполняются несколько проверочных
* итераций, в конце каждой из которых часть записей удаляется:
* - выполняется позиционирование на значение ключа для каждого
* элемента проверочной "карты", которая была сформирована
* на предыдущем шаге.
* - проверяется успешность операции с учетом того был ли элемент
* уже удален или еще нет.
* - проверяется результирующая позиция курсора.
* - удаляется часть строк: текущая транзакция чтения закрывается,
* открывается пишущая, выполняется удаление, курсор переоткрывается.
* - после каждого удаления проверяется что позиция курсора
* соответствует ожиданиям (сделан переход к следующей записи
* в порядке курсора).
* - итерации повторяются пока не будут удалены все строки.
* - при выполнении всех проверок и удалений строки выбираются
* в стохастическом порядке.
*
* 6. Завершаются операции и освобождаются ресурсы.
*/
if (!valid_index_ops || !valid_cursor_ops || skipped)
return;
SCOPED_TRACE("type " + std::to_string(type) + ", index " +
std::to_string(index) +
(valid_index_ops ? ", (valid case)" : ", (invalid case)"));
SCOPED_TRACE(
"ordering " + std::to_string(ordering) + ", index " +
std::to_string(index) +
(valid_cursor_ops ? ", (valid cursor case)" : ", (invalid cursor case)"));
ASSERT_LT(5, n_records);
/* заполняем present "номерами" значений ключа существующих записей,
* важно что эти "номера" через карту позволяют получить соответствующее
* значения от генератора ключей */
std::vector<int> present;
std::map<int, int> dups_countdown;
for (const auto &pair : reorder) {
present.push_back(pair.first);
dups_countdown[pair.first] = fpta_index_is_unique(index) ? 1 : n_dups;
}
// сохраняем исходный полный набор
auto initial = present;
any_keygen keygen(type, index);
for (;;) {
SCOPED_TRACE("records left " + std::to_string(present.size()));
// перемешиваем
for (size_t i = 0; i < present.size(); ++i) {
auto remix = (4201 + i * 2017) % present.size();
std::swap(present[i], present[remix]);
}
for (size_t i = 0; i < initial.size(); ++i) {
auto remix = (44741 + i * 55001) % initial.size();
std::swap(initial[i], initial[remix]);
}
// начинаем транзакцию чтения если предыдущая закрыта
fpta_txn *txn = txn_guard.get();
if (!txn_guard) {
EXPECT_EQ(FPTA_OK,
fpta_transaction_begin(db_quard.get(), fpta_read, &txn));
ASSERT_NE(nullptr, txn);
txn_guard.reset(txn);
}
// открываем курсор для чтения
fpta_cursor *cursor = nullptr;
EXPECT_EQ(FPTA_OK,
fpta_cursor_open(
txn_guard.get(), &col_pk, fpta_value_begin(),
fpta_value_end(), nullptr,
(fpta_cursor_options)(ordering | fpta_dont_fetch), &cursor));
ASSERT_NE(nullptr, cursor);
cursor_guard.reset(cursor);
// проверяем позиционирование
for (size_t i = 0; i < initial.size(); ++i) {
const auto linear = initial.at(i);
ASSERT_EQ(1u, reorder.count(linear));
const auto order = reorder[linear];
int expected_dups =
dups_countdown.count(linear) ? dups_countdown.at(linear) : 0;
SCOPED_TRACE("linear " + std::to_string(linear) + ", order " +
std::to_string(order) +
(dups_countdown.count(linear) ? ", present" : ", deleted"));
fpta_value key = keygen.make(order, NNN);
size_t dups = 100500;
switch (expected_dups) {
case 0:
/* все значения уже были удалены,
* точный поиск (exactly=true) должен вернуть "нет данных" */
ASSERT_EQ(FPTA_NODATA, fpta_cursor_locate(cursor, true, &key, nullptr));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_ECURSOR, fpta_cursor_dups(cursor_guard.get(), &dups));
ASSERT_EQ((size_t)FPTA_DEADBEEF, dups);
if (present.size()) {
/* но какие-то строки в таблице еще есть, поэтому неточный
* поиск (exactly=false) должен вернуть "ОК" если:
* - для курсора определен порядок строк.
* - в порядке курсора есть строки "после" запрошенного значения
* ключа (аналогично lower_bound и с учетом того, что строк
* с заданным значением ключа уже нет). */
const auto lower_bound = dups_countdown.lower_bound(linear);
if (fpta_cursor_is_ordered(ordering) &&
lower_bound != dups_countdown.end()) {
const auto SCOPED_TRACE_ONLY expected_linear = lower_bound->first;
const auto SCOPED_TRACE_ONLY expected_order =
reorder[expected_linear];
expected_dups = lower_bound->second;
SCOPED_TRACE("lower-bound: linear " +
std::to_string(expected_linear) + ", order " +
std::to_string(expected_order) + ", n-dups " +
std::to_string(expected_dups));
ASSERT_EQ(FPTA_OK,
fpta_cursor_locate(cursor, false, &key, nullptr));
ASSERT_NO_FATAL_FAILURE(
CheckPosition(expected_linear,
/* см ниже пояснение о expected_dup_number */
n_dups - expected_dups, expected_dups));
} else {
if (fpta_cursor_is_ordered(ordering) ||
!FPTA_PROHIBIT_NEARBY4UNORDERED) {
ASSERT_EQ(FPTA_NODATA,
fpta_cursor_locate(cursor, false, &key, nullptr));
} else {
ASSERT_NE(FPTA_OK,
fpta_cursor_locate(cursor, false, &key, nullptr));
}
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_ECURSOR,
fpta_cursor_dups(cursor_guard.get(), &dups));
ASSERT_EQ((size_t)FPTA_DEADBEEF, dups);
}
} else {
if (fpta_cursor_is_ordered(ordering) ||
!FPTA_PROHIBIT_NEARBY4UNORDERED) {
ASSERT_EQ(FPTA_NODATA,
fpta_cursor_locate(cursor, false, &key, nullptr));
} else {
ASSERT_NE(FPTA_OK,
fpta_cursor_locate(cursor, false, &key, nullptr));
}
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_ECURSOR, fpta_cursor_dups(cursor_guard.get(), &dups));
ASSERT_EQ((size_t)FPTA_DEADBEEF, dups);
}
continue;
case 1:
if (fpta_cursor_is_ordered(ordering) ||
!FPTA_PROHIBIT_NEARBY4UNORDERED) {
ASSERT_EQ(FPTA_OK, fpta_cursor_locate(cursor, false, &key, nullptr));
ASSERT_NO_FATAL_FAILURE(CheckPosition(linear, -1, 1));
} else {
ASSERT_NE(FPTA_OK, fpta_cursor_locate(cursor, false, &key, nullptr));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_ECURSOR, fpta_cursor_dups(cursor_guard.get(), &dups));
}
ASSERT_EQ(FPTA_OK, fpta_cursor_locate(cursor, true, &key, nullptr));
ASSERT_NO_FATAL_FAILURE(CheckPosition(linear, -1, 1));
break;
default:
/* Пояснения о expected_dup_number:
* - курсор позиционируется на первый дубликат в порядке сортировки
* в соответствии с типом курсора;
* - удаление записей (ниже по коду) выполняется после такого
* позиционирования;
* - соответственно, постепенно удаляются все дубликаты,
* начиная с первого в порядке сортировки курсора.
*
* Таким образом, ожидаемое количество дубликатов также определяет
* dup_id первой строки-дубликата, на которую должен встать курсор. */
int const expected_dup_number = n_dups - expected_dups;
SCOPED_TRACE("multi-val: n-dups " + std::to_string(expected_dups) +
", here-dup " + std::to_string(expected_dup_number));
ASSERT_EQ(FPTA_OK, fpta_cursor_locate(cursor, true, &key, nullptr));
ASSERT_EQ(FPTA_OK, fpta_cursor_eof(cursor));
ASSERT_NO_FATAL_FAILURE(
CheckPosition(linear, expected_dup_number, expected_dups));
if (fpta_cursor_is_ordered(ordering) ||
!FPTA_PROHIBIT_NEARBY4UNORDERED) {
ASSERT_EQ(FPTA_OK, fpta_cursor_locate(cursor, false, &key, nullptr));
ASSERT_NO_FATAL_FAILURE(
CheckPosition(linear, expected_dup_number, expected_dups));
} else {
ASSERT_NE(FPTA_OK, fpta_cursor_locate(cursor, false, &key, nullptr));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_ECURSOR, fpta_cursor_dups(cursor_guard.get(), &dups));
}
break;
}
}
// закрываем читающий курсор и транзакцию
ASSERT_EQ(FPTA_OK, fpta_cursor_close(cursor_guard.release()));
cursor = nullptr;
ASSERT_EQ(FPTA_OK, fpta_transaction_end(txn_guard.release(), true));
txn = nullptr;
if (present.size() == 0)
break;
// начинаем пишущую транзакцию для удаления
EXPECT_EQ(FPTA_OK,
fpta_transaction_begin(db_quard.get(), fpta_write, &txn));
ASSERT_NE(nullptr, txn);
txn_guard.reset(txn);
// открываем курсор для удаления
EXPECT_EQ(FPTA_OK,
fpta_cursor_open(txn_guard.get(), &col_pk, fpta_value_begin(),
fpta_value_end(), nullptr, ordering, &cursor));
ASSERT_NE(nullptr, cursor);
cursor_guard.reset(cursor);
// проверяем позиционирование и удаляем
for (size_t i = present.size(); i > present.size() / 2;) {
const auto linear = present.at(--i);
const auto order = reorder.at(linear);
int expected_dups = dups_countdown.at(linear);
SCOPED_TRACE("delete: linear " + std::to_string(linear) + ", order " +
std::to_string(order) + ", dups left " +
std::to_string(expected_dups));
fpta_value key = keygen.make(order, NNN);
ASSERT_EQ(FPTA_OK, fpta_cursor_locate(cursor, true, &key, nullptr));
ASSERT_EQ(0, fpta_cursor_eof(cursor));
size_t dups = 100500;
ASSERT_EQ(FPTA_OK, fpta_cursor_dups(cursor_guard.get(), &dups));
ASSERT_EQ(expected_dups, (int)dups);
ASSERT_EQ(FPTA_OK, fpta_cursor_delete(cursor));
expected_dups = --dups_countdown.at(linear);
if (expected_dups == 0) {
present.erase(present.begin() + (int)i);
dups_countdown.erase(linear);
}
// проверяем состояние курсора и его переход к следующей строке
if (present.empty()) {
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_dups(cursor_guard.get(), &dups));
ASSERT_EQ(0u, dups);
} else if (expected_dups) {
ASSERT_NO_FATAL_FAILURE(
CheckPosition(linear,
/* см выше пояснение о expected_dup_number */
n_dups - expected_dups, expected_dups));
} else if (fpta_cursor_is_ordered(ordering)) {
const auto lower_bound = dups_countdown.lower_bound(linear);
if (lower_bound != dups_countdown.end()) {
const auto SCOPED_TRACE_ONLY expected_linear = lower_bound->first;
const auto SCOPED_TRACE_ONLY expected_order =
reorder[expected_linear];
expected_dups = lower_bound->second;
SCOPED_TRACE("after-delete: linear " +
std::to_string(expected_linear) + ", order " +
std::to_string(expected_order) + ", n-dups " +
std::to_string(expected_dups));
ASSERT_NO_FATAL_FAILURE(
CheckPosition(expected_linear,
/* см выше пояснение о expected_dup_number */
n_dups - expected_dups, expected_dups));
} else {
ASSERT_EQ(FPTA_NODATA, fpta_cursor_eof(cursor));
ASSERT_EQ(FPTA_NODATA, fpta_cursor_dups(cursor_guard.get(), &dups));
ASSERT_EQ(0u, dups);
}
}
}
// завершаем транзакцию удаления
ASSERT_EQ(FPTA_OK, fpta_cursor_close(cursor_guard.release()));
cursor = nullptr;
ASSERT_EQ(FPTA_OK, fpta_transaction_end(txn_guard.release(), false));
txn = nullptr;
}
}
//----------------------------------------------------------------------------
TEST_P(CursorPrimary, update_and_KeyMismatch) {
/* Проверка обновления через курсор, в том числе с попытками изменить
* значение "курсорной" колонки.
*
* Сценарий (общий для всех типов полей и всех видов первичных индексов):
* 1. Создается тестовая база с одной таблицей, в которой четыре колонки:
* - "col_pk" (primary key) с типом, для которого производится
* тестирование работы индекса.
* - Колонка "order", в которую записывается контрольный (ожидаемый)
* порядковый номер следования строки, при сортировке по col_pk и
* проверяемому виду индекса.
* - Колонка "dup_id", которая используется для идентификации
* дубликатов индексов допускающих не-уникальные ключи.
* - Колонка "t1ha", в которую записывается "контрольная сумма" от
* ожидаемого порядка строки, типа PK и вида индекса.
* Принципиальной необходимости в этой колонке нет, она используется
* как "утяжелитель", а также для дополнительного контроля.
*
* 2. Для валидных комбинаций вида индекса и типа данных col_pk таблица
* заполняется строками, значение col_pk в которых генерируется
* соответствующим генератором значений:
* - Сами генераторы проверяются в одном из тестов 0corny.
* - Для индексов без уникальности для каждого ключа вставляется
* 5 строк с разным dup_id.
*
* 3. Перебираются все комбинации индексов, типов колонок и видов курсора.
* Для НЕ валидных комбинаций контролируются коды ошибок.
*
* 4. Для валидных комбинаций индекса и типа курсора, после заполнения
* в отдельной транзакции формируется "карта" верификации перемещений:
* - "карта" строится как неупорядоченное отображение линейных номеров
* строк в порядке просмотра через курсор, на ожидаемые (контрольные)
* значения колонки "order".
* - при построении "карты" все строки читаются последовательно через
* проверяемый курсор.
* - для построенной "карты" проверяется размер (что прочитали все
* строки и только по одному разу) и соответствия порядка строк
* типу курсора (возрастание/убывание).
*
* 5. Примерно половина строк (без учета дубликатов) изменяется
* через курсор:
* - в качестве критерия изменять/не-менять используется
* младший бит значения колонки "t1ha".
* - в изменяемых строках инвертируется знак колонки "order",
* а колонка "dup_id" устанавливается в 4242.
* - при каждом реальном обновлении делается две попытки обновить
* строку с изменением значения ключевой "курсорной" колонки.
*
* 6. Выполняется проверка всех строк, как исходных, так и измененных.
* При наличии дубликатов, измененные строки ищутся по значению
* колонки "dup_id".
*/
if (!valid_index_ops || !valid_cursor_ops || skipped)
return;
SCOPED_TRACE("type " + std::to_string(type) + ", index " +
std::to_string(index) +
(valid_index_ops ? ", (valid case)" : ", (invalid case)"));
SCOPED_TRACE(
"ordering " + std::to_string(ordering) + ", index " +
std::to_string(index) +
(valid_cursor_ops ? ", (valid cursor case)" : ", (invalid cursor case)"));
any_keygen keygen(type, index);
const int expected_dups = fpta_index_is_unique(index) ? 1 : n_dups;
// закрываем читающий курсор и транзакцию
ASSERT_EQ(FPTA_OK, fpta_cursor_close(cursor_guard.release()));
ASSERT_EQ(FPTA_OK, fpta_transaction_end(txn_guard.release(), true));
// начинаем пишущую транзакцию для изменений
fpta_txn *txn = nullptr;
EXPECT_EQ(FPTA_OK, fpta_transaction_begin(db_quard.get(), fpta_write, &txn));
ASSERT_NE(nullptr, txn);
txn_guard.reset(txn);
// открываем курсор для изменения
fpta_cursor *cursor = nullptr;
EXPECT_EQ(FPTA_OK,
fpta_cursor_open(txn_guard.get(), &col_pk, fpta_value_begin(),
fpta_value_end(), nullptr, ordering, &cursor));
ASSERT_NE(nullptr, cursor);
cursor_guard.reset(cursor);
// обновляем половину строк
for (int order = 0; order < NNN; ++order) {
SCOPED_TRACE("order " + std::to_string(order));
fpta_value value_pk = keygen.make(order, NNN);
ASSERT_EQ(FPTA_OK, fpta_cursor_locate(cursor, true, &value_pk, nullptr));
ASSERT_EQ(FPTA_OK, fpta_cursor_eof(cursor_guard.get()));
fptu_ro tuple;
ASSERT_EQ(FPTA_OK, fpta_cursor_get(cursor_guard.get(), &tuple));
ASSERT_STREQ(nullptr, fptu::check(tuple));
int error;
auto tuple_order = (int)fptu_get_sint(tuple, col_order.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
ASSERT_EQ(order, tuple_order);
auto tuple_checksum = fptu_get_uint(tuple, col_t1ha.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
const auto checksum = order_checksum(tuple_order, type, index).uint;
ASSERT_EQ(checksum, tuple_checksum);
if (checksum & 1) {
uint8_t buffer[(fpta_max_keylen + 4) * 4 + sizeof(fptu_rw)];
fptu_rw *row = fptu_fetch(tuple, buffer, sizeof(buffer), 1);
ASSERT_NE(nullptr, row);
ASSERT_STREQ(nullptr, fptu::check(row));
// инвертируем знак order и пытаемся обновить строку с изменением ключа
ASSERT_EQ(FPTA_OK, fpta_upsert_column(row, &col_order,
fpta_value_sint(-tuple_order)));
value_pk = keygen.make((order + 42) % NNN, NNN);
ASSERT_EQ(FPTA_OK, fpta_upsert_column(row, &col_pk, value_pk));
ASSERT_EQ(FPTA_KEY_MISMATCH,
fpta_cursor_probe_and_update(cursor, fptu_take(row)));
// восстанавливаем значение ключа и обновляем строку
value_pk = keygen.make(order, NNN);
ASSERT_EQ(FPTA_OK, fpta_upsert_column(row, &col_pk, value_pk));
// для простоты контроля среди дубликатов устанавливаем dup_id = 4242
ASSERT_EQ(FPTA_OK,
fpta_upsert_column(row, &col_dup_id, fpta_value_sint(4242)));
ASSERT_EQ(FPTA_OK, fpta_cursor_probe_and_update(cursor, fptu_take(row)));
// для проверки еще раз пробуем "сломать" ключ
value_pk = keygen.make((order + 24) % NNN, NNN);
ASSERT_EQ(FPTA_OK, fpta_upsert_column(row, &col_pk, value_pk));
ASSERT_EQ(FPTA_KEY_MISMATCH,
fpta_cursor_probe_and_update(cursor, fptu_take_noshrink(row)));
size_t ndups;
ASSERT_EQ(FPTA_OK, fpta_cursor_dups(cursor, &ndups));
ASSERT_EQ(expected_dups, (int)ndups);
}
}
// завершаем транзакцию изменения
ASSERT_EQ(FPTA_OK, fpta_cursor_close(cursor_guard.release()));
cursor = nullptr;
ASSERT_EQ(FPTA_OK, fpta_transaction_commit(txn_guard.release()));
txn = nullptr;
// начинаем транзакцию чтения если предыдущая закрыта
EXPECT_EQ(FPTA_OK, fpta_transaction_begin(db_quard.get(), fpta_read, &txn));
ASSERT_NE(nullptr, txn);
txn_guard.reset(txn);
// открываем курсор для чтения
EXPECT_EQ(FPTA_OK,
fpta_cursor_open(txn_guard.get(), &col_pk, fpta_value_begin(),
fpta_value_end(), nullptr,
(fpta_cursor_options)(ordering | fpta_dont_fetch),
&cursor));
ASSERT_NE(nullptr, cursor);
cursor_guard.reset(cursor);
// проверяем обновления
for (int order = 0; order < NNN; ++order) {
SCOPED_TRACE("order " + std::to_string(order));
const fpta_value value_pk = keygen.make(order, NNN);
fptu_ro tuple;
int error;
ASSERT_EQ(FPTA_OK, fpta_cursor_locate(cursor, true, &value_pk, nullptr));
ASSERT_EQ(FPTA_OK, fpta_cursor_eof(cursor_guard.get()));
size_t ndups;
ASSERT_EQ(FPTA_OK, fpta_cursor_dups(cursor, &ndups));
ASSERT_EQ(expected_dups, (int)ndups);
const auto checksum = order_checksum(order, type, index).uint;
for (;;) {
ASSERT_EQ(FPTA_OK, fpta_cursor_get(cursor_guard.get(), &tuple));
ASSERT_STREQ(nullptr, fptu::check(tuple));
auto tuple_checksum = fptu_get_uint(tuple, col_t1ha.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
ASSERT_EQ(checksum, tuple_checksum);
auto tuple_dup_id =
(int)fptu_get_uint(tuple, col_dup_id.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
// идем по строкам-дубликатом до той, которую обновляли
if (tuple_dup_id != 4242 && (checksum & 1))
ASSERT_EQ(FPTA_OK, fpta_cursor_move(cursor, fpta_dup_next));
else
break;
}
auto tuple_order = (int)fptu_get_sint(tuple, col_order.column.num, &error);
ASSERT_EQ(FPTU_OK, error);
int expected_order = order;
if (checksum & 1)
expected_order = -expected_order;
EXPECT_EQ(expected_order, tuple_order);
}
}
//----------------------------------------------------------------------------
#ifdef INSTANTIATE_TEST_SUITE_P
INSTANTIATE_TEST_SUITE_P(
Combine, CursorPrimary,
::testing::Combine(
::testing::Values(fptu_null, fptu_uint16, fptu_int32, fptu_uint32,
fptu_fp32, fptu_int64, fptu_uint64, fptu_fp64,
fptu_datetime, fptu_96, fptu_128, fptu_160, fptu_256,
fptu_cstr, fptu_opaque
/*, fptu_nested, fptu_farray */),
::testing::Values(fpta_primary_unique_ordered_obverse,
fpta_primary_unique_ordered_reverse,
fpta_primary_withdups_ordered_obverse,
fpta_primary_withdups_ordered_reverse,
fpta_primary_unique_unordered,
fpta_primary_withdups_unordered),
::testing::Values(fpta_unsorted, fpta_ascending, fpta_descending)));
INSTANTIATE_TEST_SUITE_P(
Combine, CursorPrimaryDups,
::testing::Combine(
::testing::Values(fptu_null, fptu_uint16, fptu_int32, fptu_uint32,
fptu_fp32, fptu_int64, fptu_uint64, fptu_fp64,
fptu_datetime, fptu_96, fptu_128, fptu_160, fptu_256,
fptu_cstr, fptu_opaque
/*, fptu_nested, fptu_farray */),
::testing::Values(fpta_primary_withdups_ordered_obverse,
fpta_primary_withdups_ordered_reverse,
fpta_primary_withdups_unordered),
::testing::Values(fpta_unsorted, fpta_ascending, fpta_descending)));
#else
INSTANTIATE_TEST_CASE_P(
Combine, CursorPrimary,
::testing::Combine(
::testing::Values(fptu_null, fptu_uint16, fptu_int32, fptu_uint32,
fptu_fp32, fptu_int64, fptu_uint64, fptu_fp64,
fptu_datetime, fptu_96, fptu_128, fptu_160, fptu_256,
fptu_cstr, fptu_opaque
/*, fptu_nested, fptu_farray */),
::testing::Values(fpta_primary_unique_ordered_obverse,
fpta_primary_unique_ordered_reverse,
fpta_primary_withdups_ordered_obverse,
fpta_primary_withdups_ordered_reverse,
fpta_primary_unique_unordered,
fpta_primary_withdups_unordered),
::testing::Values(fpta_unsorted, fpta_ascending, fpta_descending)));
INSTANTIATE_TEST_CASE_P(
Combine, CursorPrimaryDups,
::testing::Combine(
::testing::Values(fptu_null, fptu_uint16, fptu_int32, fptu_uint32,
fptu_fp32, fptu_int64, fptu_uint64, fptu_fp64,
fptu_datetime, fptu_96, fptu_128, fptu_160, fptu_256,
fptu_cstr, fptu_opaque
/*, fptu_nested, fptu_farray */),
::testing::Values(fpta_primary_withdups_ordered_obverse,
fpta_primary_withdups_ordered_reverse,
fpta_primary_withdups_unordered),
::testing::Values(fpta_unsorted, fpta_ascending, fpta_descending)));
#endif
int main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 68,099 | 27,027 |
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <unordered_map>
#include <string>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
struct stackst{
TreeNode * node;
int depth;
stackst(TreeNode * n, int d): node(n), depth(d){}
};
public:
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int> > re;
if(!root) return re;
queue<stackst> st;
stackst temp = stackst(NULL, -1);
int curd= 0;
vector<int> ve;
bool l2r = true;
st.push(stackst(root, 0));
while(!st.empty()){
temp = st.front(); st.pop();
// cout<<temp.node->val<<'\n';
if(temp.node->left)
st.push(stackst(temp.node->left, temp.depth + 1));
if(temp.node->right)
st.push(stackst(temp.node->right, temp.depth + 1));
if(temp.depth != curd){
if(l2r){
re.push_back(ve);
l2r = false;
}
else{
reverse(ve.begin(), ve.end());
re.push_back(ve);
l2r = true;
}
curd++;
ve = {};
}
ve.push_back(temp.node->val);
// cout<<ve.size()<<"ASdf\n";
}
if(l2r){
re.push_back(ve);
l2r = false;
}
else{
reverse(ve.begin(), ve.end());
re.push_back(ve);
l2r = true;
}
return re;
}
// WITHOUT STACKST
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> res;
queue<TreeNode*> q;
auto level = 0;
if (!root)
return res;
q.push(root);
while (not q.empty()) {
auto size = q.size();
vector<int> v;
for (auto i = 0; i < size; i++) {
TreeNode *t = q.front();
q.pop();
v.push_back(t->val);
if (t->left)
q.push(t->left);
if (t->right)
q.push(t->right);
}
if (level % 2 == 1)
reverse(v.begin(), v.end());
res.push_back(v);
level++;
}
return res;
}
};
| 2,608 | 808 |
/*
* "$Id: bitmap.c,v 1.2 1996/01/09 22:52:53 mike Exp mike $"
*
* Device Independent Bitmap functions for OpenGL under MS Windows.
*
* Contents:
*
* LoadDIBitmap() - Load a DIB/BMP file from disk.
* SaveDIBitmap() - Save a bitmap to a DIB/BMP file on disk.
* ReadDIBitmap() - Read the current OpenGL viewport into a
* 24-bit RGB bitmap.
* PrintDIBitmap() - Print a bitmap to a GDI printer.
* ConvertRGB() - Convert a DIB/BMP image to 24-bit RGB pixels.
*
* Revision History:
*
* $Log: bitmap.c,v $
* Revision 1.2 1996/01/09 22:52:53 mike
* Added PrintDIBitmap.
*
* Revision 1.1 1995/12/31 07:27:17 mike
* Initial revision
*/
/*
* Include necessary headers.
*/
#include "bitmap.h"
/*
* 'LoadDIBitmap()' - Load a DIB/BMP file from disk.
*
* Returns a pointer to the bitmap if successful, NULL otherwise...
*/
void *
LoadDIBitmap(char *filename, /* I - File to load */
BITMAPINFO **info) /* O - Bitmap information */
{
FILE *fp; /* Open file pointer */
void *bits; /* Bitmap pixel bits */
unsigned long bitsize, /* Size of bitmap */
infosize; /* Size of header information */
BITMAPFILEHEADER header; /* File header */
/*
* Try opening the file; use "rb" mode to read this *binary* file.
*/
if ((fp = fopen(filename, "rb")) == NULL)
return (NULL);
/*
* Read the file header and any following bitmap information...
*/
if (fread(&header, sizeof(BITMAPFILEHEADER), 1, fp) < 1)
{
/*
* Couldn't read the file header - return NULL...
*/
fclose(fp);
return (NULL);
};
/*
if (header.bfType != 'MB') // Check for BM reversed...
{
// Not a bitmap file - return NULL...
//printf("Not a bitmap file!\n");
//fclose(fp);
//return (NULL);
};
*/
infosize = header.bfOffBits - sizeof(BITMAPFILEHEADER);
if ((*info = (BITMAPINFO *)malloc(infosize)) == NULL)
{
/*
* Couldn't allocate memory for bitmap info - return NULL...
*/
fclose(fp);
return (NULL);
};
if (fread(*info, 1, infosize, fp) < infosize)
{
/*
* Couldn't read the bitmap header - return NULL...
*/
free(*info);
fclose(fp);
return (NULL);
};
/*
* Now that we have all the header info read in, allocate memory for the
* bitmap and read *it* in...
*/
if ((bitsize = (*info)->bmiHeader.biSizeImage) == 0)
bitsize = ((*info)->bmiHeader.biWidth *
(*info)->bmiHeader.biBitCount + 7) / 8 *
abs((*info)->bmiHeader.biHeight);
if ((bits = malloc(bitsize)) == NULL)
{
/*
* Couldn't allocate memory - return NULL!
*/
free(*info);
fclose(fp);
return (NULL);
};
if (fread(bits, 1, bitsize, fp) < bitsize)
{
/*
* Couldn't read bitmap - free memory and return NULL!
*/
free(*info);
free(bits);
fclose(fp);
return (NULL);
};
/*
* OK, everything went fine - return the allocated bitmap...
*/
fclose(fp);
return (bits);
}
/*
* 'SaveDIBitmap()' - Save a bitmap to a DIB/BMP file on disk.
*
* Returns 0 if successful, non-zero otherwise...
*/
int
SaveDIBitmap(char *filename, /* I - File to save to */
BITMAPINFO *info, /* I - Bitmap information */
void *bits) /* I - Bitmap pixel bits */
{
FILE *fp; /* Open file pointer */
unsigned long size, /* Size of file */
infosize, /* Size of bitmap info */
bitsize; /* Size of bitmap pixels */
BITMAPFILEHEADER header; /* File header */
/*
* Try opening the file; use "wb" mode to write this *binary* file.
*/
if ((fp = fopen(filename, "wb")) == NULL)
return (-1);
if (info->bmiHeader.biSizeImage == 0) /* Figure out the bitmap size */
bitsize = (info->bmiHeader.biWidth *
info->bmiHeader.biBitCount + 7) / 8 *
abs(info->bmiHeader.biHeight);
else
bitsize = info->bmiHeader.biSizeImage;
infosize = sizeof(BITMAPINFOHEADER);
switch (info->bmiHeader.biCompression)
{
case BI_BITFIELDS :
infosize += 12; /* Add 3 RGB doubleword masks */
if (info->bmiHeader.biClrUsed == 0)
break;
case BI_RGB :
if (info->bmiHeader.biBitCount > 8 &&
info->bmiHeader.biClrUsed == 0)
break;
case BI_RLE8 :
case BI_RLE4 :
if (info->bmiHeader.biClrUsed == 0)
infosize += (1 << info->bmiHeader.biBitCount) * 4;
else
infosize += info->bmiHeader.biClrUsed * 4;
break;
};
size = sizeof(BITMAPFILEHEADER) + infosize + bitsize;
/*
* Write the file header, bitmap information, and bitmap pixel data...
*/
header.bfType = 'MB'; /* Non-portable... sigh */
header.bfSize = size;
header.bfReserved1 = 0;
header.bfReserved2 = 0;
header.bfOffBits = sizeof(BITMAPFILEHEADER) + infosize;
if (fwrite(&header, 1, sizeof(BITMAPFILEHEADER), fp) < sizeof(BITMAPFILEHEADER))
{
/*
* Couldn't write the file header - return...
*/
fclose(fp);
return (-1);
};
if (fwrite(info, 1, infosize, fp) < infosize)
{
/*
* Couldn't write the bitmap header - return...
*/
fclose(fp);
return (-1);
};
if (fwrite(bits, 1, bitsize, fp) < bitsize)
{
/*
* Couldn't write the bitmap - return...
*/
fclose(fp);
return (-1);
};
/*
* OK, everything went fine - return...
*/
fclose(fp);
return (0);
}
/*
* 'ReadDIBitmap()' - Read the current OpenGL viewport into a
* 24-bit RGB bitmap.
*
* Returns the bitmap pixels if successful and NULL otherwise.
*/
void *
ReadDIBitmap(BITMAPINFO **info) /* O - Bitmap information */
{
long i, j, /* Looping var */
bitsize, /* Total size of bitmap */
width; /* Aligned width of a scanline */
GLint viewport[4]; /* Current viewport */
void *bits; /* RGB bits */
GLubyte *rgb, /* RGB looping var */
temp; /* Temporary var for swapping */
/*
* Grab the current viewport...
*/
glGetIntegerv(GL_VIEWPORT, viewport);
/*
* Allocate memory for the header and bitmap...
*/
if ((*info = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER))) == NULL)
{
/*
* Couldn't allocate memory for bitmap info - return NULL...
*/
return (NULL);
};
width = viewport[2] * 3; /* Real width of scanline */
width = (width + 3) & ~3; /* Aligned to 4 bytes */
bitsize = width * viewport[3]; /* Size of bitmap, aligned */
if ((bits = calloc(bitsize, 1)) == NULL)
{
/*
* Couldn't allocate memory for bitmap pixels - return NULL...
*/
free(*info);
return (NULL);
};
/*
* Read pixels from the framebuffer...
*/
glFinish(); /* Finish all OpenGL commands */
glPixelStorei(GL_PACK_ALIGNMENT, 4); /* Force 4-byte alignment */
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
glReadPixels(0, 0, viewport[2], viewport[3], GL_RGB, GL_UNSIGNED_BYTE,
bits);
/*
* Swap red and blue for the bitmap...
*/
for (i = 0; i < viewport[3]; i ++)
for (j = 0, rgb = ((GLubyte *)bits) + i * width;
j < viewport[2];
j ++, rgb += 3)
{
temp = rgb[0];
rgb[0] = rgb[2];
rgb[2] = temp;
};
/*
* Finally, initialize the bitmap header information...
*/
(*info)->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
(*info)->bmiHeader.biWidth = viewport[2];
(*info)->bmiHeader.biHeight = viewport[3];
(*info)->bmiHeader.biPlanes = 1;
(*info)->bmiHeader.biBitCount = 24;
(*info)->bmiHeader.biCompression = BI_RGB;
(*info)->bmiHeader.biSizeImage = bitsize;
(*info)->bmiHeader.biXPelsPerMeter = 2952; /* 75 DPI */
(*info)->bmiHeader.biYPelsPerMeter = 2952; /* 75 DPI */
(*info)->bmiHeader.biClrUsed = 0;
(*info)->bmiHeader.biClrImportant = 0;
return (bits);
}
/*
* 'PrintDIBitmap()' - Print a bitmap to a GDI printer.
*/
int
PrintDIBitmap(HWND owner, /* I - Owner/parent window */
BITMAPINFO *info, /* I - Bitmap information */
void *bits) /* I - Bitmap pixel bits */
{
PRINTDLG pd; /* Print dialog information */
long xsize, /* Size of printed image */
ysize,
xoffset, /* Offset from edges for image */
yoffset;
RECT rect; /* Page rectangle */
DOCINFO di; /* Document info */
HDC hdc; /* Device context for bitmap */
HBITMAP bitmap; /* Bitmap image */
HBRUSH brush; /* Background brush for page */
HCURSOR busy, /* Busy cursor */
oldcursor; /* Old cursor */
/*
* Range check...
*/
if (info == NULL || bits == NULL)
return (0);
/*
* Initialize a PRINTDLG structure before displaying a standard Windows
* print dialog...
*/
memset(&pd, 0, sizeof(pd));
pd.lStructSize = sizeof(pd);
pd.hwndOwner = owner;
pd.Flags = PD_RETURNDC;
pd.hInstance = NULL;
if (!PrintDlg(&pd))
return (0); /* User chose 'cancel'... */
/*
* OK, user wants to print, so set the cursor to 'busy' and start the
* print job...
*/
busy = LoadCursor(NULL, IDC_WAIT);
oldcursor = SetCursor(busy);
SetMapMode(pd.hDC, MM_TEXT);
di.cbSize = sizeof(DOCINFO);
di.lpszDocName = "OpenGL Image";
di.lpszOutput = NULL;
StartDoc(pd.hDC, &di);
StartPage(pd.hDC);
/*
* Clear the background to white...
*/
rect.top = 0;
rect.left = 0;
rect.right = GetDeviceCaps(pd.hDC, HORZRES);
rect.bottom = GetDeviceCaps(pd.hDC, VERTRES);
brush = CreateSolidBrush(0x00ffffff);
FillRect(pd.hDC, &rect, brush);
/*
* Stretch the bitmap to fit the page...
*/
hdc = CreateCompatibleDC(pd.hDC);
bitmap = CreateDIBitmap(hdc, &(info->bmiHeader), CBM_INIT, bits, info,
DIB_RGB_COLORS);
SelectObject(hdc, bitmap);
xsize = rect.right;
ysize = xsize * info->bmiHeader.biHeight / info->bmiHeader.biWidth;
if (ysize > rect.bottom)
{
ysize = rect.bottom;
xsize = ysize * info->bmiHeader.biWidth / info->bmiHeader.biHeight;
};
xoffset = (rect.right - xsize) / 2;
yoffset = (rect.bottom - ysize) / 2;
StretchBlt(pd.hDC, xoffset, yoffset, xsize, ysize,
hdc, 0, 0, info->bmiHeader.biWidth, info->bmiHeader.biHeight,
SRCCOPY);
/*
* That's it. End the print job and free anything we allocated...
*/
EndPage(pd.hDC);
EndDoc(pd.hDC);
DeleteDC(pd.hDC);
DeleteObject(bitmap);
DeleteObject(brush);
DeleteObject(busy);
DeleteDC(hdc);
/*
* Restore the cursor and return...
*/
SetCursor(oldcursor);
return (1);
}
/*
* 'ConvertRGB()' - Convert a DIB/BMP image to 24-bit RGB pixels.
*
* Returns an RGB pixel array if successful and NULL otherwise.
*/
GLubyte *
ConvertRGB(BITMAPINFO *info, /* I - Original bitmap information */
void *bits) /* I - Original bitmap pixels */
{
int i, j, /* Looping vars */
bitsize, /* Total size of bitmap */
width; /* Aligned width of bitmap */
GLubyte *newbits; /* New RGB bits */
GLubyte *from, *to;//, /* RGB looping vars */
//temp; /* Temporary var for swapping */
/*
* Allocate memory for the RGB bitmap...
*/
width = 3 * info->bmiHeader.biWidth;
width = (width + 3) & ~3;
bitsize = width * info->bmiHeader.biHeight;
if ((newbits = (GLubyte *)calloc(bitsize, 1)) == NULL)
return (NULL);
/*
* Copy the original bitmap to the new array, converting as necessary.
*/
switch (info->bmiHeader.biCompression)
{
case BI_RGB :
if (info->bmiHeader.biBitCount == 24)
{
/*
* Swap red & blue in a 24-bit image...
*/
for (i = 0; i < info->bmiHeader.biHeight; i++)
for (j = 0, from = ((GLubyte *)bits) + i * width,
to = newbits + i * width;
j < info->bmiHeader.biWidth;
j++, from += 3, to += 3)
{
to[0] = from[2];
to[1] = from[1];
to[2] = from[0];
};
};
break;
case BI_RLE4 :
case BI_RLE8 :
case BI_BITFIELDS :
break;
};
return (newbits);
}
/*
* End of "$Id: bitmap.c,v 1.2 1996/01/09 22:52:53 mike Exp mike $".
*/
| 12,662 | 4,981 |
/*
* Copyright 2017 The Cartographer Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "cartographer/cloud/internal/map_builder_server.h"
#include "cartographer/cloud/internal/handlers/add_fixed_frame_pose_data_handler.h"
#include "cartographer/cloud/internal/handlers/add_imu_data_handler.h"
#include "cartographer/cloud/internal/handlers/add_landmark_data_handler.h"
#include "cartographer/cloud/internal/handlers/add_odometry_data_handler.h"
#include "cartographer/cloud/internal/handlers/add_rangefinder_data_handler.h"
#include "cartographer/cloud/internal/handlers/add_sensor_data_batch_handler.h"
#include "cartographer/cloud/internal/handlers/add_trajectory_handler.h"
#include "cartographer/cloud/internal/handlers/finish_trajectory_handler.h"
#include "cartographer/cloud/internal/handlers/get_all_submap_poses.h"
#include "cartographer/cloud/internal/handlers/get_constraints_handler.h"
#include "cartographer/cloud/internal/handlers/get_landmark_poses_handler.h"
#include "cartographer/cloud/internal/handlers/get_local_to_global_transform_handler.h"
#include "cartographer/cloud/internal/handlers/get_submap_handler.h"
#include "cartographer/cloud/internal/handlers/get_trajectory_node_poses_handler.h"
#include "cartographer/cloud/internal/handlers/is_trajectory_finished_handler.h"
#include "cartographer/cloud/internal/handlers/is_trajectory_frozen_handler.h"
#include "cartographer/cloud/internal/handlers/load_state_handler.h"
#include "cartographer/cloud/internal/handlers/receive_global_slam_optimizations_handler.h"
#include "cartographer/cloud/internal/handlers/receive_local_slam_results_handler.h"
#include "cartographer/cloud/internal/handlers/run_final_optimization_handler.h"
#include "cartographer/cloud/internal/handlers/set_landmark_pose_handler.h"
#include "cartographer/cloud/internal/handlers/write_state_handler.h"
#include "cartographer/cloud/internal/sensor/serialization.h"
#include "glog/logging.h"
namespace cartographer {
namespace cloud {
namespace {
static auto* kIncomingDataQueueMetric = metrics::Gauge::Null();
const common::Duration kPopTimeout = common::FromMilliseconds(100);
} // namespace
MapBuilderServer::MapBuilderServer(
const proto::MapBuilderServerOptions& map_builder_server_options,
std::unique_ptr<mapping::MapBuilderInterface> map_builder)
: map_builder_(std::move(map_builder)) {
async_grpc::Server::Builder server_builder;
server_builder.SetServerAddress(map_builder_server_options.server_address());
server_builder.SetNumGrpcThreads(
map_builder_server_options.num_grpc_threads());
server_builder.SetNumEventThreads(
map_builder_server_options.num_event_threads());
if (!map_builder_server_options.uplink_server_address().empty()) {
local_trajectory_uploader_ = CreateLocalTrajectoryUploader(
map_builder_server_options.uplink_server_address(),
map_builder_server_options.upload_batch_size(),
map_builder_server_options.enable_ssl_encryption());
}
server_builder.RegisterHandler<handlers::AddTrajectoryHandler>();
server_builder.RegisterHandler<handlers::AddOdometryDataHandler>();
server_builder.RegisterHandler<handlers::AddImuDataHandler>();
server_builder.RegisterHandler<handlers::AddRangefinderDataHandler>();
server_builder.RegisterHandler<handlers::AddFixedFramePoseDataHandler>();
server_builder.RegisterHandler<handlers::AddLandmarkDataHandler>();
server_builder.RegisterHandler<handlers::AddSensorDataBatchHandler>();
server_builder.RegisterHandler<handlers::FinishTrajectoryHandler>();
server_builder
.RegisterHandler<handlers::ReceiveGlobalSlamOptimizationsHandler>();
server_builder.RegisterHandler<handlers::ReceiveLocalSlamResultsHandler>();
server_builder.RegisterHandler<handlers::GetSubmapHandler>();
server_builder.RegisterHandler<handlers::GetTrajectoryNodePosesHandler>();
server_builder.RegisterHandler<handlers::GetLandmarkPosesHandler>();
server_builder.RegisterHandler<handlers::GetAllSubmapPosesHandler>();
server_builder.RegisterHandler<handlers::GetLocalToGlobalTransformHandler>();
server_builder.RegisterHandler<handlers::GetConstraintsHandler>();
server_builder.RegisterHandler<handlers::IsTrajectoryFinishedHandler>();
server_builder.RegisterHandler<handlers::IsTrajectoryFrozenHandler>();
server_builder.RegisterHandler<handlers::LoadStateHandler>();
server_builder.RegisterHandler<handlers::RunFinalOptimizationHandler>();
server_builder.RegisterHandler<handlers::WriteStateHandler>();
server_builder.RegisterHandler<handlers::SetLandmarkPoseHandler>();
grpc_server_ = server_builder.Build();
if (map_builder_server_options.map_builder_options()
.use_trajectory_builder_2d()) {
grpc_server_->SetExecutionContext(
common::make_unique<MapBuilderContext<mapping::Submap2D>>(this));
} else if (map_builder_server_options.map_builder_options()
.use_trajectory_builder_3d()) {
grpc_server_->SetExecutionContext(
common::make_unique<MapBuilderContext<mapping::Submap3D>>(this));
} else {
LOG(FATAL)
<< "Set either use_trajectory_builder_2d or use_trajectory_builder_3d";
}
map_builder_->pose_graph()->SetGlobalSlamOptimizationCallback(
std::bind(&MapBuilderServer::OnGlobalSlamOptimizations, this,
std::placeholders::_1, std::placeholders::_2));
}
void MapBuilderServer::Start() {
shutting_down_ = false;
if (local_trajectory_uploader_) {
local_trajectory_uploader_->Start();
}
StartSlamThread();
grpc_server_->Start();
}
void MapBuilderServer::WaitForShutdown() {
grpc_server_->WaitForShutdown();
if (slam_thread_) {
slam_thread_->join();
}
if (local_trajectory_uploader_) {
local_trajectory_uploader_->Shutdown();
}
}
void MapBuilderServer::Shutdown() {
shutting_down_ = true;
grpc_server_->Shutdown();
if (slam_thread_) {
slam_thread_->join();
slam_thread_.reset();
}
if (local_trajectory_uploader_) {
local_trajectory_uploader_->Shutdown();
local_trajectory_uploader_.reset();
}
}
void MapBuilderServer::ProcessSensorDataQueue() {
LOG(INFO) << "Starting SLAM thread.";
while (!shutting_down_) {
kIncomingDataQueueMetric->Set(incoming_data_queue_.Size());
std::unique_ptr<MapBuilderContextInterface::Data> sensor_data =
incoming_data_queue_.PopWithTimeout(kPopTimeout);
if (sensor_data) {
grpc_server_->GetContext<MapBuilderContextInterface>()
->AddSensorDataToTrajectory(*sensor_data);
}
}
}
void MapBuilderServer::StartSlamThread() {
CHECK(!slam_thread_);
// Start the SLAM processing thread.
slam_thread_ = common::make_unique<std::thread>(
[this]() { this->ProcessSensorDataQueue(); });
}
void MapBuilderServer::OnLocalSlamResult(
int trajectory_id, common::Time time, transform::Rigid3d local_pose,
sensor::RangeData range_data,
std::unique_ptr<const mapping::TrajectoryBuilderInterface::InsertionResult>
insertion_result) {
auto shared_range_data =
std::make_shared<sensor::RangeData>(std::move(range_data));
// If there is an uplink server and a submap insertion happened, enqueue this
// local SLAM result for uploading.
if (insertion_result &&
grpc_server_->GetUnsynchronizedContext<MapBuilderContextInterface>()
->local_trajectory_uploader()) {
auto sensor_data = common::make_unique<proto::SensorData>();
auto sensor_id =
grpc_server_->GetUnsynchronizedContext<MapBuilderContextInterface>()
->local_trajectory_uploader()
->GetLocalSlamResultSensorId(trajectory_id);
CreateSensorDataForLocalSlamResult(sensor_id.id, trajectory_id, time,
starting_submap_index_,
*insertion_result, sensor_data.get());
// TODO(cschuet): Make this more robust.
if (insertion_result->insertion_submaps.front()->finished()) {
++starting_submap_index_;
}
grpc_server_->GetUnsynchronizedContext<MapBuilderContextInterface>()
->local_trajectory_uploader()
->EnqueueSensorData(std::move(sensor_data));
}
common::MutexLocker locker(&subscriptions_lock_);
for (auto& entry : local_slam_subscriptions_[trajectory_id]) {
auto copy_of_insertion_result =
insertion_result
? common::make_unique<
const mapping::TrajectoryBuilderInterface::InsertionResult>(
*insertion_result)
: nullptr;
MapBuilderContextInterface::LocalSlamSubscriptionCallback callback =
entry.second;
if (!callback(
common::make_unique<MapBuilderContextInterface::LocalSlamResult>(
MapBuilderContextInterface::LocalSlamResult{
trajectory_id, time, local_pose, shared_range_data,
std::move(copy_of_insertion_result)}))) {
LOG(INFO) << "Removing subscription with index: " << entry.first;
CHECK_EQ(local_slam_subscriptions_[trajectory_id].erase(entry.first), 1u);
}
}
}
void MapBuilderServer::OnGlobalSlamOptimizations(
const std::map<int, mapping::SubmapId>& last_optimized_submap_ids,
const std::map<int, mapping::NodeId>& last_optimized_node_ids) {
common::MutexLocker locker(&subscriptions_lock_);
for (auto& entry : global_slam_subscriptions_) {
if (!entry.second(last_optimized_submap_ids, last_optimized_node_ids)) {
LOG(INFO) << "Removing subscription with index: " << entry.first;
CHECK_EQ(global_slam_subscriptions_.erase(entry.first), 1u);
}
}
}
MapBuilderContextInterface::LocalSlamSubscriptionId
MapBuilderServer::SubscribeLocalSlamResults(
int trajectory_id,
MapBuilderContextInterface::LocalSlamSubscriptionCallback callback) {
common::MutexLocker locker(&subscriptions_lock_);
local_slam_subscriptions_[trajectory_id].emplace(current_subscription_index_,
callback);
return MapBuilderContextInterface::LocalSlamSubscriptionId{
trajectory_id, current_subscription_index_++};
}
void MapBuilderServer::UnsubscribeLocalSlamResults(
const MapBuilderContextInterface::LocalSlamSubscriptionId&
subscription_id) {
common::MutexLocker locker(&subscriptions_lock_);
CHECK_EQ(local_slam_subscriptions_[subscription_id.trajectory_id].erase(
subscription_id.subscription_index),
1u);
}
int MapBuilderServer::SubscribeGlobalSlamOptimizations(
MapBuilderContextInterface::GlobalSlamOptimizationCallback callback) {
common::MutexLocker locker(&subscriptions_lock_);
global_slam_subscriptions_.emplace(current_subscription_index_, callback);
return current_subscription_index_++;
}
void MapBuilderServer::UnsubscribeGlobalSlamOptimizations(
int subscription_index) {
common::MutexLocker locker(&subscriptions_lock_);
CHECK_EQ(global_slam_subscriptions_.erase(subscription_index), 1u);
}
void MapBuilderServer::NotifyFinishTrajectory(int trajectory_id) {
common::MutexLocker locker(&subscriptions_lock_);
for (auto& entry : local_slam_subscriptions_[trajectory_id]) {
MapBuilderContextInterface::LocalSlamSubscriptionCallback callback =
entry.second;
// 'nullptr' signals subscribers that the trajectory finished.
callback(nullptr);
}
}
void MapBuilderServer::WaitUntilIdle() {
incoming_data_queue_.WaitUntilEmpty();
map_builder_->pose_graph()->RunFinalOptimization();
}
void MapBuilderServer::RegisterMetrics(metrics::FamilyFactory* factory) {
auto* queue_length = factory->NewGaugeFamily(
"cloud_internal_map_builder_server_incoming_data_queue_length",
"Incoming SLAM Data Queue length");
kIncomingDataQueueMetric = queue_length->Add({});
}
} // namespace cloud
} // namespace cartographer
| 12,315 | 3,805 |
/*
* BSD LICENSE
* Copyright (c) 2021 Samsung Electronics Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Samsung Electronics Corporation nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "src/qos/monitoring_manager.h"
#include "src/include/pos_event_id.hpp"
#include "src/qos/qos_context.h"
#include "src/qos/qos_manager.h"
#include "src/spdk_wrapper/event_framework_api.h"
#define VALID_ENTRY (1)
#define INVALID_ENTRY (0)
#define NVMF_CONNECT (0)
#define NVMF_DISCONNECT (1)
namespace pos
{
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
QosMonitoringManager::QosMonitoringManager(QosContext* qosCtx,
QosManager* qosManager,
SpdkPosNvmfCaller* spdkPosNvmfCaller,
AffinityManager* affinityManager)
: qosContext(qosCtx),
qosManager(qosManager),
spdkPosNvmfCaller(spdkPosNvmfCaller),
affinityManager(affinityManager)
{
nextManagerType = QosInternalManager_Unknown;
for (uint32_t i = 0; i < MAX_ARRAY_COUNT; i++)
{
qosMonitoringManagerArray[i] = new QosMonitoringManagerArray(i, qosCtx, qosManager);
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
QosMonitoringManager::~QosMonitoringManager(void)
{
for (uint32_t i = 0; i < MAX_ARRAY_COUNT; i++)
{
delete qosMonitoringManagerArray[i];
}
if (spdkPosNvmfCaller != nullptr)
{
delete spdkPosNvmfCaller;
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::Execute(void)
{
if (qosManager->IsFeQosEnabled() == true)
{
_UpdateContextUserVolumePolicy();
if (true == _GatherActiveVolumeParameters())
{
_ComputeTotalActiveConnection();
}
_UpdateAllVolumeParameter();
}
_UpdateContextUserRebuildPolicy();
_GatherActiveEventParameters();
_UpdateContextResourceDetails();
_SetNextManagerType();
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_ComputeTotalActiveConnection(void)
{
uint32_t totalConntection = 0;
std::map<uint32_t, uint32_t> activeVolumeMap = qosContext->GetActiveVolumes();
std::map<uint32_t, map<uint32_t, uint32_t>> volReactorMap = qosContext->GetActiveVolumeReactors();
for (map<uint32_t, uint32_t>::iterator it = activeVolumeMap.begin(); it != activeVolumeMap.end(); it++)
{
uint32_t volId = it->first;
for (map<uint32_t, uint32_t>::iterator it = volReactorMap[volId].begin(); it != volReactorMap[volId].end(); ++it)
{
totalConntection += it->second;
}
qosContext->SetTotalConnection(volId, totalConntection);
totalConntection = 0;
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_UpdateContextUserVolumePolicy(void)
{
uint32_t maxArrays = qosManager->GetNumberOfArrays();
for (uint32_t i = 0; i < maxArrays; i++)
{
qosMonitoringManagerArray[i]->UpdateContextUserVolumePolicy();
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_UpdateContextUserRebuildPolicy(void)
{
for (uint32_t i = 0; i < MAX_ARRAY_COUNT; i++)
{
qosMonitoringManagerArray[i]->UpdateContextUserRebuildPolicy();
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_UpdateContextResourceDetails(void)
{
uint32_t maxArrays = qosManager->GetNumberOfArrays();
for (uint32_t i = 0; i < maxArrays; i++)
{
qosMonitoringManagerArray[i]->UpdateContextResourceDetails();
}
QosResource& resourceDetails = qosContext->GetQosResource();
ResourceCpu& resourceCpu = resourceDetails.GetResourceCpu();
for (uint32_t event = 0; event < BackendEvent_Count; event++)
{
uint32_t pendingEventCount = qosManager->GetPendingBackendEvents(static_cast<BackendEvent>(event));
resourceCpu.SetEventPendingCpuCount(static_cast<BackendEvent>(event), pendingEventCount);
uint32_t generatedCpuEvents = qosManager->GetEventLog(static_cast<BackendEvent>(event));
resourceCpu.SetTotalGeneratedEvents(static_cast<BackendEvent>(event), generatedCpuEvents);
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_UpdateContextActiveVolumeReactors(std::map<uint32_t, map<uint32_t, uint32_t>> map, std::map<uint32_t, std::vector<uint32_t>> &inactiveReactors)
{
qosContext->InsertActiveVolumeReactor(map);
qosContext->InsertInactiveReactors(inactiveReactors);
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_UpdateAllVolumeParameter(void)
{
std::map<uint32_t, uint32_t> activeVolumeMap = qosContext->GetActiveVolumes();
for (map<uint32_t, uint32_t>::iterator it = activeVolumeMap.begin(); it != activeVolumeMap.end(); it++)
{
uint32_t volId = it->first;
uint32_t arrVolId = volId % MAX_VOLUME_COUNT;
uint32_t arrayId = volId / MAX_VOLUME_COUNT;
qosMonitoringManagerArray[arrayId]->UpdateVolumeParameter(arrVolId);
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
bool
QosMonitoringManager::_GatherActiveVolumeParameters(void)
{
qosContext->ResetActiveVolume();
qosContext->ResetActiveReactorVolume();
qosContext->ResetAllReactorsProcessed();
QosCorrection& qosCorrection = qosContext->GetQosCorrection();
AllVolumeThrottle& allVolumeThrottle = qosCorrection.GetVolumeThrottlePolicy();
allVolumeThrottle.Reset();
QosParameters& qosParameters = qosContext->GetQosParameters();
AllVolumeParameter& allVolumeParameter = qosParameters.GetAllVolumeParameter();
allVolumeParameter.Reset();
QosParameters& qosParameter = qosContext->GetQosParameters();
qosParameter.Reset();
bool changeDetected = false;
std::vector<uint32_t> reactorCoreList = qosContext->GetReactorCoreList();
std::unordered_map<int32_t, std::vector<int>> subsystemVolumeMap;
std::map<uint32_t, vector<int>> volList[M_MAX_REACTORS];
while (!IsExitQosSet())
{
if (true == qosContext->AllReactorsProcessed())
{
break;
}
}
const std::map<uint32_t, map<uint32_t, uint32_t>> lastVolReactorMap = volReactorMap;
volReactorMap.clear();
reactorVolMap.clear();
inactiveReactors.clear();
bool reactorActive = false;
for (auto& reactor : reactorCoreList)
{
reactorActive = false;
volList[reactor].clear();
for (uint32_t arrayId = 0; arrayId < qosManager->GetNumberOfArrays(); arrayId++)
{
if (true == IsExitQosSet())
{
break;
}
qosManager->GetSubsystemVolumeMap(subsystemVolumeMap, arrayId);
for (auto& subsystemVolume : subsystemVolumeMap)
{
uint32_t subsystemId = subsystemVolume.first;
if (spdkPosNvmfCaller->SpdkNvmfGetReactorSubsystemMapping(reactor, subsystemId) != INVALID_SUBSYSTEM)
{
volList[reactor][subsystemId] = qosManager->GetVolumeFromActiveSubsystem(subsystemId, arrayId);
}
std::vector<int> volumeList = volList[reactor][subsystemId];
for (auto& volumeId : volumeList)
{
bool validParam = false;
reactorActive = false;
while (true)
{
bool valid = qosMonitoringManagerArray[arrayId]->VolParamActivities(volumeId, reactor);
if (valid == false)
{
break;
}
else
{
validParam = true;
}
}
uint32_t globalVolId = arrayId * MAX_VOLUME_COUNT + volumeId;
if (true == validParam)
{
reactorVolMap[reactor].insert({globalVolId, 1});
volReactorMap[globalVolId].insert({reactor, 1});
reactorActive = true;
}
if (reactorActive == false)
{
inactiveReactors[globalVolId].push_back(reactor);
}
}
}
}
}
if (lastVolReactorMap == volReactorMap)
{
changeDetected = false;
}
else
{
_UpdateContextActiveVolumeReactors(volReactorMap, inactiveReactors);
changeDetected = true;
}
if (_CheckChangeInActiveVolumes() == true)
{
qosManager->ResetCorrection();
}
return changeDetected;
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
bool
QosMonitoringManager::_CheckChangeInActiveVolumes(void)
{
static int stabilityCycleCheck = 0;
std::map<uint32_t, uint32_t> activeVolumeMap = qosContext->GetActiveVolumes();
bool ret = false;
if (stabilityCycleCheck == 0)
{
if (prevActiveVolumeMap == activeVolumeMap)
{
ret = false;
}
else
{
stabilityCycleCheck++;
ret = false;
}
}
else
{
if (prevActiveVolumeMap == activeVolumeMap)
{
stabilityCycleCheck++;
if (stabilityCycleCheck == 10)
{
stabilityCycleCheck = 0;
ret = true;
}
else
{
ret = false;
}
}
else
{
stabilityCycleCheck = 0;
ret = false;
}
}
prevActiveVolumeMap = activeVolumeMap;
return ret;
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_UpdateEventParameter(BackendEvent event)
{
QosParameters& qosParam = qosContext->GetQosParameters();
AllEventParameter& allEventParam = qosParam.GetAllEventParameter();
bool eventFound = allEventParam.EventExists(event);
if (true == eventFound)
{
EventParameter& eventParam = allEventParam.GetEventParameter(event);
eventParam.IncreaseBandwidth(eventParams[event].currentBW);
}
else
{
EventParameter eventParam;
eventParam.SetBandwidth(eventParams[event].currentBW);
allEventParam.InsertEventParameter(event, eventParam);
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_GatherActiveEventParameters(void)
{
cpu_set_t cpuSet = affinityManager->GetCpuSet(CoreType::UDD_IO_WORKER);
uint32_t cpuCount = CPU_COUNT(&cpuSet);
for (uint32_t workerId = 0; workerId < cpuCount; workerId++)
{
for (uint32_t event = 0; (BackendEvent)event < BackendEvent_Count; event++)
{
do
{
eventParams[event].valid = M_INVALID_ENTRY;
eventParams[event] = qosManager->DequeueEventParams(workerId, (BackendEvent)event);
if (eventParams[event].valid == M_VALID_ENTRY)
{
_UpdateEventParameter(static_cast<BackendEvent>(event));
}
} while ((eventParams[event].valid == M_VALID_ENTRY) && (!IsExitQosSet()));
}
}
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
void
QosMonitoringManager::_SetNextManagerType(void)
{
nextManagerType = QosInternalManager_Processing;
}
/* --------------------------------------------------------------------------*/
/**
* @Synopsis
*
* @Returns
*/
/* --------------------------------------------------------------------------*/
QosInternalManagerType
QosMonitoringManager::GetNextManagerType(void)
{
return nextManagerType;
}
} // namespace pos
| 15,235 | 4,467 |
/*
* Copyright 2013-2019 Automatak, LLC
*
* Licensed to Green Energy Corp (www.greenenergycorp.com) and Automatak
* LLC (www.automatak.com) under one or more contributor license agreements.
* See the NOTICE file distributed with this work for additional information
* regarding copyright ownership. Green Energy Corp and Automatak LLC license
* this file to you under the Apache License, Version 2.0 (the "License"); you
* may not use this file except in compliance with the License. You may obtain
* a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "opendnp3/app/IINField.h"
#include <openpal/util/ToHex.h>
using namespace openpal;
using namespace std;
namespace opendnp3
{
bool IINField::IsSet(IINBit bit) const
{
switch (bit)
{
case (IINBit::ALL_STATIONS):
return Get(LSBMask::ALL_STATIONS);
case (IINBit::CLASS1_EVENTS):
return Get(LSBMask::CLASS1_EVENTS);
case (IINBit::CLASS2_EVENTS):
return Get(LSBMask::CLASS2_EVENTS);
case (IINBit::CLASS3_EVENTS):
return Get(LSBMask::CLASS3_EVENTS);
case (IINBit::NEED_TIME):
return Get(LSBMask::NEED_TIME);
case (IINBit::LOCAL_CONTROL):
return Get(LSBMask::LOCAL_CONTROL);
case (IINBit::DEVICE_TROUBLE):
return Get(LSBMask::DEVICE_TROUBLE);
case (IINBit::DEVICE_RESTART):
return Get(LSBMask::DEVICE_RESTART);
case (IINBit::FUNC_NOT_SUPPORTED):
return Get(MSBMask::FUNC_NOT_SUPPORTED);
case (IINBit::OBJECT_UNKNOWN):
return Get(MSBMask::OBJECT_UNKNOWN);
case (IINBit::PARAM_ERROR):
return Get(MSBMask::PARAM_ERROR);
case (IINBit::EVENT_BUFFER_OVERFLOW):
return Get(MSBMask::EVENT_BUFFER_OVERFLOW);
case (IINBit::ALREADY_EXECUTING):
return Get(MSBMask::ALREADY_EXECUTING);
case (IINBit::CONFIG_CORRUPT):
return Get(MSBMask::CONFIG_CORRUPT);
case (IINBit::RESERVED1):
return Get(MSBMask::RESERVED1);
case (IINBit::RESERVED2):
return Get(MSBMask::RESERVED2);
default:
return false;
};
}
void IINField::SetBitToValue(IINBit bit, bool value)
{
if (value)
{
SetBit(bit);
}
else
{
ClearBit(bit);
}
}
void IINField::SetBit(IINBit bit)
{
switch (bit)
{
case (IINBit::ALL_STATIONS):
Set(LSBMask::ALL_STATIONS);
break;
case (IINBit::CLASS1_EVENTS):
Set(LSBMask::CLASS1_EVENTS);
break;
case (IINBit::CLASS2_EVENTS):
Set(LSBMask::CLASS2_EVENTS);
break;
case (IINBit::CLASS3_EVENTS):
Set(LSBMask::CLASS3_EVENTS);
break;
case (IINBit::NEED_TIME):
Set(LSBMask::NEED_TIME);
break;
case (IINBit::LOCAL_CONTROL):
Set(LSBMask::LOCAL_CONTROL);
break;
case (IINBit::DEVICE_TROUBLE):
Set(LSBMask::DEVICE_TROUBLE);
break;
case (IINBit::DEVICE_RESTART):
Set(LSBMask::DEVICE_RESTART);
break;
case (IINBit::FUNC_NOT_SUPPORTED):
Set(MSBMask::FUNC_NOT_SUPPORTED);
break;
case (IINBit::OBJECT_UNKNOWN):
Set(MSBMask::OBJECT_UNKNOWN);
break;
case (IINBit::PARAM_ERROR):
Set(MSBMask::PARAM_ERROR);
break;
case (IINBit::EVENT_BUFFER_OVERFLOW):
Set(MSBMask::EVENT_BUFFER_OVERFLOW);
break;
case (IINBit::ALREADY_EXECUTING):
Set(MSBMask::ALREADY_EXECUTING);
break;
case (IINBit::CONFIG_CORRUPT):
Set(MSBMask::CONFIG_CORRUPT);
break;
case (IINBit::RESERVED1):
Set(MSBMask::RESERVED1);
break;
case (IINBit::RESERVED2):
Set(MSBMask::RESERVED2);
break;
default:
break;
};
}
void IINField::ClearBit(IINBit bit)
{
switch (bit)
{
case (IINBit::ALL_STATIONS):
Clear(LSBMask::ALL_STATIONS);
break;
case (IINBit::CLASS1_EVENTS):
Clear(LSBMask::CLASS1_EVENTS);
break;
case (IINBit::CLASS2_EVENTS):
Clear(LSBMask::CLASS2_EVENTS);
break;
case (IINBit::CLASS3_EVENTS):
Clear(LSBMask::CLASS3_EVENTS);
break;
case (IINBit::NEED_TIME):
Clear(LSBMask::NEED_TIME);
break;
case (IINBit::LOCAL_CONTROL):
Clear(LSBMask::LOCAL_CONTROL);
break;
case (IINBit::DEVICE_TROUBLE):
Clear(LSBMask::DEVICE_TROUBLE);
break;
case (IINBit::DEVICE_RESTART):
Clear(LSBMask::DEVICE_RESTART);
break;
case (IINBit::FUNC_NOT_SUPPORTED):
Clear(MSBMask::FUNC_NOT_SUPPORTED);
break;
case (IINBit::OBJECT_UNKNOWN):
Clear(MSBMask::OBJECT_UNKNOWN);
break;
case (IINBit::PARAM_ERROR):
Clear(MSBMask::PARAM_ERROR);
break;
case (IINBit::EVENT_BUFFER_OVERFLOW):
Clear(MSBMask::EVENT_BUFFER_OVERFLOW);
break;
case (IINBit::ALREADY_EXECUTING):
Clear(MSBMask::ALREADY_EXECUTING);
break;
case (IINBit::CONFIG_CORRUPT):
Clear(MSBMask::CONFIG_CORRUPT);
break;
case (IINBit::RESERVED1):
Clear(MSBMask::RESERVED1);
break;
case (IINBit::RESERVED2):
Clear(MSBMask::RESERVED2);
break;
default:
break;
};
}
bool IINField::operator==(const IINField& aRHS) const
{
return (LSB == aRHS.LSB) && (MSB == aRHS.MSB);
}
} // namespace opendnp3
| 5,708 | 2,183 |
/*
* Copyright 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "MediaPlayerService-DeathNotifier"
#include <android-base/logging.h>
#include "DeathNotifier.h"
namespace android {
class DeathNotifier::DeathRecipient :
public IBinder::DeathRecipient,
public hardware::hidl_death_recipient {
public:
using Notify = DeathNotifier::Notify;
DeathRecipient(Notify const& notify): mNotify{notify} {
}
virtual void binderDied(wp<IBinder> const&) override {
mNotify();
}
virtual void serviceDied(uint64_t, wp<HBase> const&) override {
mNotify();
}
private:
Notify mNotify;
};
DeathNotifier::DeathNotifier(sp<IBinder> const& service, Notify const& notify)
: mService{std::in_place_index<1>, service},
mDeathRecipient{new DeathRecipient(notify)} {
service->linkToDeath(mDeathRecipient);
}
DeathNotifier::DeathNotifier(sp<HBase> const& service, Notify const& notify)
: mService{std::in_place_index<2>, service},
mDeathRecipient{new DeathRecipient(notify)} {
service->linkToDeath(mDeathRecipient, 0);
}
DeathNotifier::DeathNotifier(DeathNotifier&& other)
: mService{other.mService}, mDeathRecipient{other.mDeathRecipient} {
other.mService.emplace<0>();
other.mDeathRecipient = nullptr;
}
DeathNotifier::~DeathNotifier() {
switch (mService.index()) {
case 0:
break;
case 1:
std::get<1>(mService)->unlinkToDeath(mDeathRecipient);
break;
case 2:
std::get<2>(mService)->unlinkToDeath(mDeathRecipient);
break;
default:
CHECK(false) << "Corrupted service type during destruction.";
}
}
} // namespace android
| 2,281 | 762 |
#include "TerminatorAnimInstance.h"
UTerminatorAnimInstance::UTerminatorAnimInstance() {
this->ForwardLean = 0.00f;
}
| 124 | 49 |
//
// Reference.hpp
// integral
//
// MIT License
//
// Copyright (c) 2016, 2017, 2019, 2020, 2021 André Pereira Henriques (aphenriques (at) outlook (dot) com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#ifndef integral_Reference_hpp
#define integral_Reference_hpp
#include "ReferenceBase.hpp"
#include "ArgumentException.hpp"
#include "Caller.hpp"
namespace integral::detail {
template<typename K, typename C>
class Reference : public ReferenceBase<Reference<K, C>> {
public:
template<typename L, typename D>
inline Reference(L &&key, D &&chainedReference);
inline lua_State * getLuaState() const;
inline void push() const;
bool isNil() const;
template<typename T, typename ...A>
Reference<K, C> & emplace(A &&...arguments);
template<typename V>
inline Reference<K, C> & set(V &&value);
template<typename V>
inline Reference<K, C> & operator=(V &&value);
template<typename F, typename ...E, std::size_t ...I>
inline Reference<K, C> & setFunction(F &&function, DefaultArgument<E, I> &&...defaultArguments);
template<typename F>
inline Reference<K, C> & setLuaFunction(F &&function);
template<typename V>
decltype(auto) get() const;
// the conversion operator does not return a reference to an object
// storing a reference to a Lua object is unsafe because it might be collected
// Reference::get returns a reference to an object but it is not meant to be stored
template<typename V>
inline operator V() const;
// the arguments are pushed by value onto the lua stack
template<typename R, typename ...A>
decltype(auto) call(A &&...arguments);
};
//--
template<typename K, typename C>
template<typename L, typename D>
inline Reference<K, C>::Reference(L &&key, D &&chainedReference) :
ReferenceBase<Reference<K, C>>(std::forward<L>(key), std::forward<D>(chainedReference))
{}
template<typename K, typename C>
inline lua_State * Reference<K, C>::getLuaState() const {
return ReferenceBase<Reference<K, C>>::getChainedReference().getLuaState();
}
template<typename K, typename C>
inline void Reference<K, C>::push() const {
ReferenceBase<Reference<K, C>>::getChainedReference().push();
ReferenceBase<Reference<K, C>>::pushValueFromTable(getLuaState());
}
template<typename K, typename C>
bool Reference<K, C>::isNil() const {
push();
// stack: ?
if (lua_isnil(getLuaState(), -1) == 0) {
// stack: ?
lua_pop(getLuaState(), 1);
return false;
} else {
// stack: nil
lua_pop(getLuaState(), 1);
return true;
}
}
template<typename K, typename C>
template<typename T, typename ...A>
Reference<K, C> & Reference<K, C>::emplace(A &&...arguments) {
ReferenceBase<Reference<K, C>>::getChainedReference().push();
// stack: ?
if (lua_istable(getLuaState(), -1) != 0) {
// stack: chainedReferenceTable
exchanger::push<K>(getLuaState(), ReferenceBase<Reference<K, C>>::getKey());
// stack: chainedReferenceTable | key
exchanger::push<T>(getLuaState(), std::forward<A>(arguments)...);
// stack: chainedReferenceTable | key | value
lua_rawset(getLuaState(), -3);
// stack: chainedReferenceTable
lua_pop(getLuaState(), 1);
// stack:
return *this;
} else {
// stack: ?
lua_pop(getLuaState(), 1);
throw ReferenceException(__FILE__, __LINE__, __func__, std::string("[integral] reference ") + ReferenceBase<Reference<K, C>>::getReferenceString() + " is not a table");
}
}
template<typename K, typename C>
template<typename V>
inline Reference<K, C> & Reference<K, C>::set(V &&value) {
return emplace<std::decay_t<V>>(std::forward<V>(value));
}
template<typename K, typename C>
template<typename V>
inline Reference<K, C> & Reference<K, C>::operator=(V &&value) {
return set(std::forward<V>(value));
}
template<typename K, typename C>
template<typename F, typename ...E, std::size_t ...I>
inline Reference<K, C> & Reference<K, C>::setFunction(F &&function, DefaultArgument<E, I> &&...defaultArguments) {
return set(makeFunctionWrapper(std::forward<F>(function), std::move(defaultArguments)...));
}
template<typename K, typename C>
template<typename F>
inline Reference<K, C> & Reference<K, C>::setLuaFunction(F &&function) {
return set(LuaFunctionWrapper(std::forward<F>(function)));
}
template<typename K, typename C>
template<typename V>
decltype(auto) Reference<K, C>::get() const {
push();
// stack: ?
try {
decltype(auto) returnValue = exchanger::get<V>(getLuaState(), -1);
// stack: value
lua_pop(getLuaState(), 1);
// stack:
return returnValue;
} catch (const ArgumentException &argumentException) {
// stack: ?
lua_pop(getLuaState(), 1);
// stack:
throw ReferenceException(__FILE__, __LINE__, __func__, std::string("[integral] invalid type getting reference " ) + ReferenceBase<Reference<K, C>>::getReferenceString() + ": " + argumentException.what());
}
}
template<typename K, typename C>
template<typename V>
inline Reference<K, C>::operator V() const {
return get<V>();
}
template<typename K, typename C>
template<typename R, typename ...A>
decltype(auto) Reference<K, C>::call(A &&...arguments) {
push();
// stack: ?
try {
// detail::Caller<R, A...>::call pops the first element of the stack
return detail::Caller<R, A...>::call(getLuaState(), std::forward<A>(arguments)...);
} catch (const ArgumentException &argumentException) {
throw ReferenceException(__FILE__, __LINE__, __func__, std::string("[integral] invalid type calling function reference " ) + ReferenceBase<Reference<K, C>>::getReferenceString() + ": " + argumentException.what());
} catch (const CallerException &callerException) {
throw ReferenceException(__FILE__, __LINE__, __func__, std::string("[integral] error calling function reference " ) + ReferenceBase<Reference<K, C>>::getReferenceString() + ": " + callerException.what());
}
}
}
#endif
| 7,683 | 2,296 |
///////////////////////////////////////////////////////////////////////////////
// //
// polar v1.0 - August the 15th 2019 //
// //
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// //
// Copyright 2019 Matteo Tommasini //
// //
// Licensed under the Apache License, Version 2.0 (the "License"); //
// you may not use this file except in compliance with the License. //
// You may obtain a copy of the License at //
// //
// http://www.apache.org/licenses/LICENSE-2.0 //
// //
// Unless required by applicable law or agreed to in writing, software //
// distributed under the License is distributed on an "AS IS" BASIS, //
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. //
// See the License for the specific language governing permissions and //
// limitations under the License. //
// //
///////////////////////////////////////////////////////////////////////////////
#ifndef VCD_H
#define VCD_H
#include "units.hpp"
#include "gaussiandataset.hpp"
#include "vibrasolver.hpp"
///////////////////////////////////////////////////////////////////////////////////
// VCD is a legacy class meant to reproduce data provided in Gaussian09 output, //
// namely dipole and rotatory strengths (in deprecated CGS units). //
// The simulation of VCD spectra is taken care of by the vibpolarizability class //
///////////////////////////////////////////////////////////////////////////////////
class VCD
{
private:
Eigen::VectorXd intensities;
std::vector<Eigen::Vector3d> dmu_dq,
dm_dqdot;
Eigen::VectorXd m10_robust;
Eigen::VectorXd mu01_robust;
public:
VCD();
VCD(const VibraSolver&, const GaussianDataset&);
// getters
Eigen::VectorXd GetIntensities() const;
Eigen::VectorXd Get_m10_Robust() const;
Eigen::VectorXd Get_mu01_Robust() const;
std::vector<Eigen::Vector3d> GetElectricDipoleDerivativesVsNormalCoordinates() const;
std::vector<Eigen::Vector3d> GetMagneticDipoleDerivativesVsNormalCoordinates() const;
// utility
void ComputeElectricDipoleDerivativesVsNormalCoordinates(const VibraSolver&, const GaussianDataset&);
void ComputeMagneticDipoleDerivativesVsNormalCoordinates(const VibraSolver&, const GaussianDataset&);
};
#endif // VCD_H
| 3,139 | 763 |
//
// Created by stumbo on 18-11-5.
//
#include <ilcplex/ilocplex.h>
#include "pathSmoother.h"
#include "tools.h"
#include "TurnPoint.h"
#include <iostream>
#include <cmath>
#include <map>
#include <set>
using namespace std;
HGJ::pathPlanner::pathPlanner() = default;
const HGJ::WayPoints &
HGJ::pathPlanner::genCurv(WayPoints wayPoints, double ts, double maxErr,
double beginSpdInput, double endSpdInput) {
if (!wayPoints.empty()) {
WayPoints modifiedWP;
modifiedWP.reserve(wayPoints.size());
modifiedWP.push_back(wayPoints.front());
for (int i = 1; i < wayPoints.size() - 1; ++i) {
if (wayPoints[i] == wayPoints[i - 1]) {
continue;
}
if (isnan(TurnPoint{wayPoints[i-1], wayPoints[i], wayPoints[i+1]}.beta)) {
continue;
}
modifiedWP.push_back(wayPoints[i]);
}
size_t i = wayPoints.size() - 1;
if (wayPoints[i] != wayPoints[i - 1]) {
modifiedWP.push_back(wayPoints[i]);
}
wayPoints.swap(modifiedWP);
}
/// load the setting
pathPlanner::maxErr = maxErr;
pathPlanner::ts = ts;
pathPlanner::beginSpd = beginSpdInput;
pathPlanner::endSpd = endSpdInput;
/// cal the point count
int64_t pointCount = wayPoints.size();
int64_t lineCount = pointCount - 1;
int64_t cornerCount = pointCount - 2;
/// clear the last calculation
resDis = 0.0;
answerCurve.clear();
/// only one(zero) point is inputed, return the point
if (pointCount <= 1) {
cerr << "you only add 1 point" << endl;
answerCurve = wayPoints;
return answerCurve;
}
/// only two points are added, smooth the line
if (pointCount == 2) {
cerr << "you only add 2 points" << endl;
turnPoints.clear();
lineTypes.clear();
turnPoints.emplace_back(wayPoints[0], wayPoints[0], wayPoints[1]);
/// the distance may be not long enough for the speed change
double safeDis = calChangeSpdDistance(pathPlanner::beginSpd, pathPlanner::endSpd);
double theDis = (wayPoints[1] - wayPoints[0]).len();
/// the distance is not long enough, the end speed need to be modified
if (theDis < safeDis) {
pathPlanner::endSpd = calBestSpdFromDistance(
pathPlanner::beginSpd, theDis,
(pathPlanner::endSpd >pathPlanner::beginSpd));
cerr << "the end spd is not possible, fall back to:" << pathPlanner::endSpd << endl;
lineTypes.emplace_back(ONEACC, pathPlanner::endSpd);
} else {
lineTypes.push_back(
calLineType(pathPlanner::beginSpd, pathPlanner::endSpd, theDis));
}
assignLinePartPoints(0);
return answerCurve;
}
/// cal the curveLength, not used for now
curveLength = 0.0;
for (uint64_t i = 1; i < pointCount; ++i) {
curveLength += (wayPoints[i] - wayPoints[i-1]).len();
}
/// init the containers
lineTypes.clear();
lineTypes.reserve(static_cast<unsigned long>(lineCount));
lineTypes.assign(static_cast<unsigned long>(lineCount), make_pair(UNSET, 0));
turnPoints.clear();
turnPoints.reserve(static_cast<unsigned long>(cornerCount));
for (int64_t i = 0; i < cornerCount; i++) {
/// in the constructor, parameters about the corner are all calculated
turnPoints.emplace_back(wayPoints[i], wayPoints[i + 1], wayPoints[i + 2]);
}
/// the answers(d) will be stored in "turnPoints"
lpSolveTheDs(turnPoints);
/// firstly set the speed of every corner to max
for (auto & corner : turnPoints) {
corner.speed = corner.maxSpd;
}
/// check the speed of every corner continously until they are all ok.
/**
* the violations: the length between two turns can't satisfy the speed change between
* two max speed. the results are stored in map(speed, turns) in order of speed
*/
map<double, vector<uint64_t>> violations;
/// check the first and the end turn, to set a better max speed
/// which solve the condition when the begin/end speed is too small for the first/end turn
auto & firstTurn = turnPoints.front();
if (pathPlanner::beginSpd < firstTurn.speed) {
auto safeSpd = calBestSpdFromDistance(
pathPlanner::beginSpd, firstTurn.lenBefore - firstTurn.d);
if (safeSpd < firstTurn.speed) {
firstTurn.maxSpd = safeSpd;
firstTurn.speed = safeSpd;
}
}
auto & endTurn = turnPoints.back();
if (pathPlanner::endSpd < endTurn.speed) {
auto safeSpd = calBestSpdFromDistance(
pathPlanner::endSpd, endTurn.lenAfter - endTurn.d);
if (safeSpd < endTurn.speed) {
endTurn.maxSpd = safeSpd;
endTurn.speed = safeSpd;
}
}
/**check lenBefore of every turn
* if lenBefore is not long enough for the speed change
* record the slower spd and the index*/
for (uint64_t i = 1; i < turnPoints.size(); i++) {
auto & thisTurn = turnPoints[i];
auto & lastTurn = turnPoints[i - 1];
auto minDis = calChangeSpdDistance(lastTurn.speed, thisTurn.speed);
if (minDis > thisTurn.lenBefore - thisTurn.d - lastTurn.d) {
if (thisTurn.speed < lastTurn.speed) {
violations[thisTurn.speed].push_back(i);
} else {
violations[lastTurn.speed].push_back(i-1);
}
}
}
/// modify the speed continusly, from the slower to faster to ensure the plan is the best.
/// in the progress, new violations might be added
for (auto & vioVectorPair: violations) {
/// the index which violated at speed of "vioVectorPair.first"
auto & vioIndexVector = vioVectorPair.second;
/// the size of the vioIndexVector may changed, C++11 for (:) CAN NOT be used
for (uint64_t vector_i = 0; vector_i < vioIndexVector.size(); vector_i++) {
auto indexOfTurns = vioIndexVector[vector_i];
auto & thisTurn = turnPoints[indexOfTurns];
/// this means that the turn has been modified, no need to do it again
if (thisTurn.isSpdModifiedComplete()) {
continue;
}
if (indexOfTurns != 0) { /// it's not the first turn, check the spd of perious turn
auto & turnBefore = turnPoints[indexOfTurns - 1];
if (turnBefore.speed > thisTurn.speed) {
auto safeSpd = calBestSpdFromDistance(
thisTurn.speed, thisTurn.lenBefore - thisTurn.d - turnBefore.d);
if (turnBefore.speed > safeSpd) { /// turnBefore.speed is too fast!
turnBefore.speed = safeSpd;
if (indexOfTurns > 1) { /// check if the BBfore Turn becomces violation
auto & turnBBefore = turnPoints[indexOfTurns - 2];
if (turnBBefore.speed > turnBefore.speed) {
auto safeDis = calChangeSpdDistance
(turnBefore.speed, turnBBefore.speed);
if (safeDis > turnBefore.lenBefore
- (turnBBefore.d + turnBefore.d)) {
violations[turnBefore.speed].push_back(indexOfTurns - 1);
}
}
}
}
}
}
/// it's almost the same as last section
if (indexOfTurns != cornerCount - 1) {
auto & turnAfter = turnPoints[indexOfTurns + 1];
if (turnAfter.speed > thisTurn.speed) {
auto safeSpd = calBestSpdFromDistance(
thisTurn.speed, thisTurn.lenAfter - thisTurn.d - turnAfter.d);
if (turnAfter.speed > safeSpd) {
turnAfter.speed = safeSpd;
if (indexOfTurns < cornerCount - 2) {
auto & turnAAfter = turnPoints[indexOfTurns + 2];
if (turnAAfter.speed > turnAfter.speed) {
auto safeDis = calChangeSpdDistance
(turnAAfter.speed, turnAfter.speed);
if (safeDis > turnAfter.lenAfter
- (turnAAfter.d + turnAfter.d)) {
violations[turnAfter.speed].push_back(indexOfTurns + 1);
}
}
}
}
}
}
/// one turn may be modified twice
thisTurn.completeSpdModify();
}
}
/// at here, the spd of every turn has been set to the fastest speed.
/// if the beginSpd or the endSpd are too fast, they need to be slower down
if (firstTurn.speed < pathPlanner::beginSpd) {
auto safeDis = calChangeSpdDistance(firstTurn.speed, pathPlanner::beginSpd);
auto theReadDis = firstTurn.lenBefore - firstTurn.d;
if (safeDis > theReadDis) {
auto safeSpd = calBestSpdFromDistance(firstTurn.speed, theReadDis);
cerr << "[WARNING] the begin speed you set is not safe:" << pathPlanner::beginSpd <<
" ,the plan will use the max safe speed: " << safeSpd << endl;
pathPlanner::beginSpd = safeSpd;
}
}
if (endTurn.speed < pathPlanner::endSpd) {
auto safeDis = calChangeSpdDistance(endTurn.speed, pathPlanner::endSpd);
auto theReadDis = endTurn.lenAfter - endTurn.d;
if (safeDis > theReadDis) {
auto safeSpd = calBestSpdFromDistance(endTurn.speed, theReadDis);
cerr << "[WARNING] the end speed you set is not safe:" << pathPlanner::endSpd <<
" ,the plan will use the max safe speed: " << safeSpd << endl;
pathPlanner::endSpd = safeSpd;
}
}
/**
* cal the speed type of erery line progress
*/
lineTypes.front() = calLineType(pathPlanner::beginSpd, turnPoints.front().speed,
turnPoints.front().lenBefore - turnPoints.front().d);
for (uint64_t index_line = 1; index_line < lineTypes.size() - 1; ++index_line) {
auto & beforeTurn = turnPoints[index_line - 1];
auto & afterTurn = turnPoints[index_line];
lineTypes[index_line] = calLineType(beforeTurn.speed, afterTurn.speed,
beforeTurn.lenAfter - beforeTurn.d - afterTurn.d);
}
lineTypes.back() = calLineType(turnPoints.back().speed, pathPlanner::endSpd,
turnPoints.back().lenAfter - turnPoints.back().d);
/**
* plan the speed according to the ts
*/
for (uint32_t i = 0; i < turnPoints.size(); ++i) {
assignLinePartPoints(i);
assignTurnPartPoints(turnPoints[i], true);
assignTurnPartPoints(turnPoints[i], false);
}
assignLinePartPoints(lineTypes.size() - 1);
return answerCurve;
}
void HGJ::pathPlanner::lpSolveTheDs(vector<TurnPoint> & turnPoints) {
/**
* start linear programing
* using library IBM CPLEX
*/
int64_t cornerCount = turnPoints.size();
IloEnv env;
IloModel model(env);
/**
* d[0] ~ d[cornerCount - 1] is d
* d[cornerCount] is the max curvature
*/
IloNumVarArray d(env);
/**
* constrictions
*/
IloRangeArray constrictions(env);
/**
* the optimize target (-sum(d) - n*maxcurvature) minnest
*/
IloObjective optimizeTarget = IloMinimize(env);
/// adding the d varibles
for (int i = 0; i < cornerCount; i++) {
double minLen = min(turnPoints[i].lenAfter, turnPoints[i].lenBefore);
/// adding 0.45 for some speed change available in some situations
d.add(IloNumVar(env, 0.0, minLen * 0.45));
}
/// this is the max curvature
d.add(IloNumVar(env, 0.0, +IloInfinity));
for (int i = 0; i < cornerCount; i++) {
/// the curvature of every corner should be smaller than the max curvature
constrictions.add(IloRange(env, -IloInfinity, 0.0));
double coeff_d2Kmax = turnPoints[i].coeff_d2Rmin;
constrictions[i].setLinearCoef(d[i], -coeff_d2Kmax);
constrictions[i].setLinearCoef(d[cornerCount], 1);
/// the optimization target of Ds
optimizeTarget.setLinearCoef(d[i], -coeff_d2Kmax);
}
/// the maxcurvature with coeff of n-1
optimizeTarget.setLinearCoef(d[cornerCount], - cornerCount + 1);
double coeff_beta2d = c4 * maxErr;
for (int i = 0; i < cornerCount; i++) {
/// d should not be too big to bigger than the global max error
constrictions.add(IloRange(env, -IloInfinity, coeff_beta2d / cos(turnPoints[i].beta)));
constrictions[cornerCount + i].setLinearCoef(d[i], 1);
}
/// d0 + d1 <= len(p1p2), might be useless with 0.45 coeff
for (int i = 0; i < cornerCount - 1; i++) {
constrictions.add(IloRange(env, -IloInfinity , turnPoints[i].lenAfter));
constrictions[cornerCount * 2 + i].setLinearCoef(d[i], 1);
constrictions[cornerCount * 2 + i].setLinearCoef(d[i + 1], 1);
}
/// d0 < len(p0p1) / 2 (leave the space for speed up
constrictions.add(IloRange(env, -IloInfinity , turnPoints.front().lenBefore / 2.0));
constrictions[cornerCount * 3 - 1].setLinearCoef(d[0], 1);
/// dn < len(pn pn+1) / 2
constrictions.add(IloRange(env, -IloInfinity , turnPoints.back().lenAfter / 2.0));
constrictions[cornerCount * 3].setLinearCoef(d[cornerCount - 1], 1);
model.add(optimizeTarget);
model.add(constrictions);
IloCplex cplex(model);
cplex.solve();
IloNumArray ds(env);
cplex.getValues(ds, d);
// env.out() << "Solution status = " << cplex.getStatus() << endl;
// env.out() << "Solution value = " << cplex.getObjValue() << endl;
env.out() << "Values = " << ds << endl;
/// load the answers(d)
for (int i = 0; i < ds.getSize() - 1; i++) {
auto & tp = turnPoints[i];
tp.setD(static_cast<double>(ds[i]), spdMax, accMax);
/// use precise len may speed up the progress. but not tested
// tp.calPreciseHalfLen();
curveLength += 2 * (tp.halfLength - tp.d);
}
env.end();
}
double HGJ::pathPlanner::calChangeSpdDuration(double dv) {
dv = abs(dv);
double t1 = 1.875 * dv / accMax;
double t2 = 5.7735 * dv / jerkMax;
t2 = sqrt(t2);
return max(t1, t2);
}
double HGJ::pathPlanner::calChangeSpdDistance(double v0, double v1) {
return (v0 + v1) / 2.0 * calChangeSpdDuration(v0 - v1);
}
/**
* represent the maxJerk when speed change form v0 to v1
* f(v1) = v1^3 + v0v1^2 - v0^2v1 - v0^3
* @return f(v1)
*/
inline double calFunc(double v0, double v1) {
return (v1 + v0) * (v1 - v0) * (v1 + v0);
}
/**
* the gradient of the previous function
* f(v1) = v1^3 + v0v1^2 - v0^2v1 - v0^3
* f'(v1) = 3v1^2 + 2v0v1 - v0^2
* @return f'(v1)
*/
inline double calSlope(double v0, double v1) {
return (v1 + v0) * (3.0 * v1 - v0);
}
double HGJ::pathPlanner::calBestSpdFromDistance(double v0, double dist, bool faster) {
if (!faster) {
cout << "[calBestSpdFromDistance] slower example" << endl;
}
if (abs(dist) < 0.01) {
return v0;
}
/// cal the vel from the accMax constract
double tempSqrtDiff = 1.06666666666 * accMax * dist;
double v1Acc;
if (faster) {
v1Acc = sqrt(v0 * v0 + tempSqrtDiff);
} else {
if (v0 * v0 - tempSqrtDiff > 0) {
v1Acc = sqrt(v0 * v0 - tempSqrtDiff);
} else{
v1Acc = 0;
}
}
/// cal the vel from the jerkMax constract
/// solve the qubic function using gradient descent
/// targetY represent the speed related to the JerkMax
double targetY = 0.69282 * dist * dist * jerkMax;
if (!faster) {
targetY = - targetY;
/// the function cal the min jerk, there is a local min at v0/3
double minJerk = calFunc(v0, v0 / 3.0);
/// if the min is small enough, the constraction is from the accMax, return the v1Acc
if (minJerk < targetY) {
return v1Acc;
}
}
/// starting at v0, the gradient descent progress may be not fast
double v1Jerk = v0;
double currentY = 0;
double threshold = targetY * 1e-5;
while (abs(currentY - targetY) > threshold) {
v1Jerk += (targetY - currentY) / calSlope(v0, v1Jerk);
currentY = calFunc(v0, v1Jerk);
}
if (faster) {
return min(v1Acc, v1Jerk);
} else {
return max(v1Acc, v1Jerk);
}
}
pair<HGJ::pathPlanner::LinearSpdType, double>
HGJ::pathPlanner::calLineType(double v0, double v1, double dist) {
/// the min lenth means the speed change is only speed up or speed down from v0 to v1
double minDist = calChangeSpdDistance(v0, v1);
if (dist <= minDist * 1.025) {
return make_pair(ONEACC, max(v0, v1));
}
/// the min dist needed if we want to speed up to spdMax
double minDist2SpdMax = calLineSpdUpDownMinDistance(v0, v1, spdMax);
double distDiff = minDist2SpdMax - dist;
/**
* if maxDist < dist, means we can speed up to the max speed in the line
*/
if (distDiff < 0) {
return make_pair(TOMAXSPD, spdMax);
}
/// if not, using dichotomy to find the max speed we can reach
double upperBound = spdMax;
double lowerBound = max(v0, v1);
double midSpd = (upperBound + lowerBound) / 2;
double tollerance = dist / 1000.0;
while (true) {
distDiff = calLineSpdUpDownMinDistance(v0, v1, midSpd) - dist;
/**
* CaledDist > realDist ==> spd need to be slower
*/
if (distDiff > tollerance) {
upperBound = midSpd;
midSpd = (midSpd + lowerBound) / 2.0;
}
/**
* CaledDist > realDist ==> spd can be higher
*/
else if(distDiff < 0) {
lowerBound = midSpd;
midSpd = (midSpd + upperBound) / 2.0;
} else {
break;
}
}
return make_pair(SPDUPDOWN, midSpd);
}
double HGJ::pathPlanner::calLineSpdUpDownMinDistance(double v0, double v1, double vMid) {
auto dist = calChangeSpdDistance(v0, vMid);
dist += calChangeSpdDistance(vMid, v1);
return dist;
}
double HGJ::pathPlanner::calChangeSpdPosition(double v0, double dv, double t, double sumT) {
double tRatio = t / sumT;
double ans = 2.5 - (3 - tRatio) * tRatio;
ans = ans * tRatio * tRatio * tRatio * dv + v0;
return ans * t;
}
void HGJ::pathPlanner::assignSpdChangePoints(double beginV, double endV,
const vec3f & posBegin, const vec3f & posEnd) {
auto unitVec = posEnd - posBegin;
/// means there is noting to assign
if (unitVec.len() == 0.0) {
return;
}
unitVec /= unitVec.len();
double dv = endV - beginV;
double sumT = calChangeSpdDuration(dv);
/// at the begin of the whole progress, the progress t_init will be NAN
double t = ts - resDis / beginV;
if (beginV == 0.0) {
t = 0.0;
}
double distProgress;
/// build the points
while (t < sumT) {
distProgress = calChangeSpdPosition(beginV, dv, t, sumT);
answerCurve.emplace_back(posBegin + unitVec * distProgress);
t += ts;
}
if (!answerCurve.empty()) {
resDis = (answerCurve.back() - posEnd).len();
}
if (resDis < 0) {
cerr << "[pathPlanner::calChangeSpdPosition] reDis:" << resDis
<<" is smaller than 0!" << endl;
}
}
void HGJ::pathPlanner::assignLinearConstantSpeedPoints(double spd, const vec3f & posBegin,
const vec3f & posEnd) {
auto unitVec = posEnd - posBegin;
if (unitVec.len() == 0.0) {
return;
}
double sumT = unitVec.len() / spd;
unitVec /= unitVec.len();
double t = ts - resDis / spd;
while (t < sumT) {
answerCurve.emplace_back(t * spd * unitVec + posBegin);
t += ts;
}
if (!answerCurve.empty()) {
resDis = (answerCurve.back() - posEnd).len();
}
if (resDis < 0) {
cerr << "[pathPlanner::assignLinearConstantSpeedPoints] reDis:" << resDis
<<" is smaller than ""0!" << endl;
}
}
void HGJ::pathPlanner::assignTurnPartPoints(const TurnPoint & turnPoint, bool firstPart) {
/// at the corner, the speed is constrant, so the point gap is constrant
double ds = ts * turnPoint.speed;
if (ds < resDis) {
cerr << "[pathPlanner::assignTurnPartPoints] the first Inc is < 0 !\nfirst part:"
<< firstPart << endl;
resDis = ds;
}
/// the dU between the gap is about ds/wholeLen
double increaseU = ds / turnPoint.halfLength;
double firstU = (ds - resDis) / turnPoint.halfLength;
double lastU = 0.0;
vec3f lastPoint;
if (firstPart) {
lastPoint = turnPoint.B1[0];
} else {
lastPoint = turnPoint.B2[3];
}
/// considering the res error, the first currentU, targetLen is different
double currentU = firstU;
vec3f currentPoint = turnPoint.calPoint(currentU, firstPart);
double targetLen = ds - resDis;
double lenNow = (currentPoint - lastPoint).len();
double error = targetLen - lenNow;
double tolleranceError = ds / 20000.0;
while (true) {
while (abs(error) > tolleranceError) {
/// we need to modify the current U
/// de/du = -len(C0C1) / delta(U)
double dedu = lenNow / (currentU - lastU);
/// newU = lastU + error / (de/du)
currentU = currentU + error / dedu;
/// after climbing it is still over 1? the curve is finished
if (currentU > 1.0) {
if (firstPart) {
resDis = (answerCurve.back() - turnPoint.B1[3]).len();
} else {
resDis = (answerCurve.back() - turnPoint.B2[0]).len();
}
return;
}
currentPoint = turnPoint.calPoint(currentU, firstPart);
lenNow = (currentPoint - lastPoint).len();
error = targetLen - lenNow;
}
/// come to here, we reslove a U that is accurate to record
lastPoint = currentPoint;
answerCurve.emplace_back(currentPoint);
targetLen = ds;
lastU = currentU;
currentU = lastU + increaseU;
/// if U is bigger than 1.0, we set it to 1.0,
/// if it can go smaller than 1, it is a good point
if (currentU > 1.0) {
currentU = 1.0;
}
currentPoint = turnPoint.calPoint(currentU, firstPart);
lenNow = (currentPoint - lastPoint).len();
error = targetLen - lenNow;
}
}
void HGJ::pathPlanner::assignLinePartPoints(uint64_t index) {
vec3f beginPos, endPos;
double beginSpd, endSpd;
/// at the start point and the end point, the spd and pos are special
if (index == 0) {
beginPos = turnPoints.front().p0;
beginSpd = pathPlanner::beginSpd;
} else {
beginPos = turnPoints[index - 1].B2[0];
beginSpd = turnPoints[index - 1].speed;
}
if (index == lineTypes.size() - 1) {
endPos = turnPoints.back().p2;
endSpd = pathPlanner::endSpd;
} else {
endPos = turnPoints[index].B1[0];
endSpd = turnPoints[index].speed;
}
auto lineType = lineTypes[index].first;
auto lineMaxSpd = lineTypes[index].second;
if (lineType == ONEACC) {
assignSpdChangePoints(beginSpd, endSpd, beginPos, endPos);
return;
} else if (lineType == SPDUPDOWN || lineType == TOMAXSPD) {
vec3f unitVec = (endPos - beginPos) / (endPos - beginPos).len();
auto firstMaxSpdDis = calChangeSpdDistance(beginSpd, lineMaxSpd);
auto firstMaxSpdPos = (unitVec * firstMaxSpdDis) + beginPos;
auto endSpdChangeDis = calChangeSpdDistance(lineMaxSpd, endSpd);
auto endMaxSpdPos = endPos - unitVec * endSpdChangeDis;
assignSpdChangePoints(beginSpd, lineMaxSpd, beginPos, firstMaxSpdPos);
if (lineType == TOMAXSPD) {
assignLinearConstantSpeedPoints(lineMaxSpd, firstMaxSpdPos, endMaxSpdPos);
assignSpdChangePoints(lineMaxSpd, endSpd, endMaxSpdPos, endPos);
} else {
assignSpdChangePoints(lineMaxSpd, endSpd, firstMaxSpdPos, endPos);
}
return;
} else if (lineType == UNSET) {
cerr << "assign a line with UNSET type!" << endl;
throw;
} else {
cerr << "assign a line with UNKNOW type!" << endl;
throw;
}
}
void HGJ::pathPlanner::setMaxJerk(double jerkMax) {
if (jerkMax > 0) {
pathPlanner::jerkMax = jerkMax;
}
}
void HGJ::pathPlanner::setMaxAcc(double accMax) {
if (accMax > 0) {
pathPlanner::accMax = accMax;
}
}
void HGJ::pathPlanner::setMaxSpeed(double spdMax) {
if (spdMax > 0) {
pathPlanner::spdMax = spdMax;
}
}
void HGJ::pathPlanner::setMaxErr(double maxErr) {
if (maxErr > 0) {
pathPlanner::maxErr = maxErr;
}
}
const HGJ::WayPoints & HGJ::pathPlanner::getLastGeneratedCurve() {
return answerCurve;
}
| 25,583 | 8,405 |
//==============================================================
// Copyright © Intel Corporation
//
// SPDX-License-Identifier: MIT
// =============================================================
#include <CL/sycl.hpp>
using namespace sycl;
static constexpr size_t N = 1024; // global size
int main() {
//# setup queue with in_order property
queue q;
std::cout << "Device : " << q.get_device().get_info<info::device::name>() << "\n";
//# initialize data array using usm
auto data = malloc_shared<int>(N, q);
for (int i = 0; i < N; i++) data[i] = i;
//# user single_task to add all numbers
q.single_task([=](){
int sum = 0;
for(int i=0;i<N;i++){
sum += data[i];
}
data[0] = sum;
}).wait();
std::cout << "Sum = " << data[0] << "\n";
free(data, q);
return 0;
}
| 817 | 291 |
/** The intro screen that is shown when launching the game *******************
* *
* Copyright (c) 2014 Florian Oetke *
* This file is distributed under the MIT License *
* See LICENSE file for details. *
\*****************************************************************************/
#pragma once
#include "../core/engine.hpp"
#include <core/renderer/camera.hpp>
#include "../core/renderer/texture.hpp"
#include "../core/renderer/shader.hpp"
#include "../core/renderer/vertex_object.hpp"
#include "../core/renderer/primitives.hpp"
#include "../core/renderer/text.hpp"
#include <core/renderer/command_queue.hpp>
namespace lux {
class Intro_screen : public Screen {
public:
Intro_screen(Engine& game_engine);
~Intro_screen()noexcept = default;
protected:
void _update(Time delta_time)override;
void _draw()override;
void _on_enter(util::maybe<Screen&> prev) override;
void _on_leave(util::maybe<Screen&> next) override;
auto _prev_screen_policy()const noexcept -> Prev_screen_policy override {
return Prev_screen_policy::discard;
}
private:
util::Mailbox_collection _mailbox;
renderer::Camera_2d _camera;
renderer::Text_dynamic _debug_Text;
renderer::Command_queue _render_queue;
};
}
| 1,434 | 454 |
/* SPDX-License-Identifier: MIT */
#include <dbt/mc/x86/reverse-allocator.h>
#include <dbt/mc/x86/formatter.h>
#include <dbt/util/list.h>
//#define PDEBUG
#define VERIFY
#define SUPPORT_VOLATILE
#define CLEVER_ALLOCATION_STRATEGY
using namespace captive::arch::dbt::mc::x86;
using namespace captive::arch::dbt::util;
#define MAX_PHYS_REGISTERS 24
template<typename UnderlyingType = dbt_u64, int NrBits = sizeof(UnderlyingType) * 8 >
struct BitSet {
static_assert(NrBits <= sizeof(UnderlyingType) * 8, "NrBits does not fit within underlying data type");
typedef BitSet<UnderlyingType, NrBits> Self;
typedef int IndexType;
BitSet() : state(0)
{
}
BitSet(const BitSet& _o) : state(_o.state)
{
}
inline operator UnderlyingType() const
{
return state;
}
inline void wipe()
{
state = 0;
}
inline void set(IndexType i)
{
state |= ((UnderlyingType) 1u << i);
}
inline void clear(IndexType i)
{
state &= ~((UnderlyingType) 1u << i);
}
inline bool is_set(IndexType i) const
{
return !!(state & ((UnderlyingType) 1u << i));
}
inline bool is_clear(IndexType i) const
{
return !(state & ((UnderlyingType) 1u << i));
}
inline IndexType find_first_set() const
{
if (state == 0) return -1;
return __builtin_ffsll(state) - 1;
}
inline IndexType find_first_clear() const
{
if (~state == 0) return -1;
return __builtin_ffsll(~state) - 1;
}
inline IndexType find_first_set_via_mask(UnderlyingType mask) const
{
if (state & mask == 0) return -1;
return __builtin_ffsll(state & mask) - 1;
}
inline IndexType find_first_clear_via_mask(UnderlyingType mask) const
{
if (((~state) & mask) == 0) return -1;
return __builtin_ffsll((~state) & mask) - 1;
}
friend Self operator|(const Self& lhs, const Self& rhs)
{
Self r;
r.state = lhs.state | rhs.state;
return r;
}
void operator|=(const Self& other)
{
state |= other.state;
}
private:
UnderlyingType state;
};
struct VirtualRegister {
Instruction *first_def, *last_use;
dbt_u64 physical_register_index;
BitSet<> interference;
int last_control_flow_count;
};
bool ReverseAllocator::allocate(Instruction* head)
{
const X86PhysicalRegister& invalid_reg = X86PhysicalRegisters::RIZ;
if (!number_and_legalise_instructions(head)) return false;
// Allocate the dense vreg map.
dbt_u64 nr_vregs = _vreg_allocator.next_index();
if (nr_vregs > 20000) {
_support.debug_printf("there are too many vregs: %lu\n", nr_vregs);
_support.assertion_fail("too many vregs");
return false;
}
VirtualRegister *vregs = (VirtualRegister *) _support.alloc(sizeof(VirtualRegister) * nr_vregs, AllocClass::DATA);
if (!vregs) return false;
// Initialise the vreg map.
for (unsigned int i = 0; i < nr_vregs; i++) {
vregs[i].first_def = nullptr;
vregs[i].last_use = nullptr;
vregs[i].physical_register_index = invalid_reg.unique_index();
vregs[i].last_control_flow_count = 0;
}
// Calculate VREG live ranges
if (!calculate_vreg_live_ranges(vregs, head)) {
_support.free(vregs, AllocClass::DATA);
return false;
}
// Make fake uses for volatile memory accesses
#ifdef SUPPORT_VOLATILE
for (unsigned int i = 0; i < nr_vregs; i++) {
if (vregs[i].first_def != nullptr && vregs[i].last_use == nullptr) {
#ifdef PDEBUG
_support.debug_printf("dead live range for vreg %lu\n", i);
#endif
Instruction *insn = vregs[i].first_def;
if (insn->is_volatile()) {
#ifdef PDEBUG
_support.debug_printf("volatile instruction, so creating fake use for vreg %lu\n", i);
Formatter __fmt;
_support.debug_printf("[%u] %s\n", insn->nr, __fmt.format_instruction(insn));
#endif
if (insn->kind() != InstructionKind::MOV) {
_support.assertion_fail("fake use: not a mov");
}
auto vreg_operand = insn->get_operand(1);
if (!vreg_operand.is_reg() || !vreg_operand.reg.reg.is_virtual()) {
_support.assertion_fail("fake use: not a vreg operand");
}
insn->set_operand(1, Operand::make_register(X86PhysicalRegisters::R14, vreg_operand.reg.width));
}
}
}
#endif
// Perform allocation
if (!do_allocate(vregs, head)) {
_support.free(vregs, AllocClass::DATA);
return false;
}
if (!commit(head, vregs)) {
_support.free(vregs, AllocClass::DATA);
return false;
}
#ifdef VERIFY
if (!verify(head)) {
_support.free(vregs, AllocClass::DATA);
return false;
}
#endif
if (!fixup_calls(head)) {
_support.free(vregs, AllocClass::DATA);
}
_support.free(vregs, AllocClass::DATA);
return true;
}
bool ReverseAllocator::calculate_vreg_live_ranges(VirtualRegister *vregs, Instruction *head)
{
#ifdef PDEBUG
VirtualRegister *last_vreg = nullptr;
#endif
int cur_control_flow_count = 0;
Instruction *current = head;
do {
if (current->is_control_flow()) {
cur_control_flow_count++;
}
Instruction::UseDefList usedeflist;
current->get_usedefs(usedeflist);
for (unsigned int use_def_index = 0; use_def_index < usedeflist.next; use_def_index++) {
const auto& usedef = usedeflist.get(use_def_index);
if (!usedef.is_valid()) continue; // Skip invalid usedefs
if (!usedef.is_def()) continue; // Skip non-def usedefs
if (!usedef.reg.is_virtual()) continue; // Skip non-virtual registers
VirtualRegister *vreg = &vregs[usedef.reg.unique_index()];
#ifdef PDEBUG
if (vreg > last_vreg) {
last_vreg = vreg;
}
#endif
if (vreg->first_def == nullptr) {
#ifdef PDEBUG
_support.debug_printf("new definition of vreg %u\n", usedef.reg.unique_index());
#endif
vreg->first_def = current;
vreg->last_control_flow_count = cur_control_flow_count;
} else if (vreg->last_use == nullptr && !usedef.is_usedef()) {
#ifdef PDEBUG
_support.debug_printf("definition of vreg %u, without use (and not a usedef) lcfc=%u, ccfc=%u\n", usedef.reg.unique_index(), vreg->last_control_flow_count, cur_control_flow_count);
#endif
#if 1
// Was there any intermediate controlflow/uses?
if (vreg->last_control_flow_count == cur_control_flow_count) {
#ifdef PDEBUG
_support.debug_printf(" no control flow! killing %u\n", vregs[usedef.reg.unique_index()].first_def->nr);
#endif
vreg->first_def->change_kind(InstructionKind::DEAD);
vreg->first_def = current;
}
#endif
}
}
for (unsigned int use_def_index = 0; use_def_index < usedeflist.next; use_def_index++) {
const auto& usedef = usedeflist.get(use_def_index);
if (!usedef.is_valid()) continue; // Skip invalid usedefs
if (!usedef.is_use()) continue; // Skip non-use usedefs
if (!usedef.reg.is_virtual()) continue; // Skip non-virtual registers
VirtualRegister *vreg = &vregs[usedef.reg.unique_index()];
#ifdef PDEBUG
if (vreg > last_vreg) {
last_vreg = vreg;
}
#endif
vreg->last_use = current;
}
current = current->next();
} while (current != head);
#ifdef PDEBUG
if (last_vreg != nullptr) {
for (VirtualRegister *vreg = vregs; vreg != last_vreg + 1; vreg++) {
if (vreg->first_def == nullptr && vreg->last_use == nullptr) continue;
dbt_u64 fd = -1, lu = -1;
if (vreg->first_def != nullptr) {
fd = vreg->first_def->nr;
}
if (vreg->last_use != nullptr) {
lu = vreg->last_use->nr;
}
_support.debug_printf("vreg %lu: start:%lu, end:%lu\n", (vreg - vregs), fd, lu);
}
}
#endif
return true;
}
#define GPR_MASK 0x0000FFFF
#define SSE_MASK 0xFFFF0000
bool ReverseAllocator::do_allocate(VirtualRegister* vregs, Instruction* head)
{
dbt_u64 phys_reg_tracking[MAX_PHYS_REGISTERS];
BitSet<> live_phys_regs;
// HACK
live_phys_regs.set(X86PhysicalRegisters::R15.unique_index());
live_phys_regs.set(X86PhysicalRegisters::BP.unique_index());
live_phys_regs.set(X86PhysicalRegisters::SP.unique_index());
phys_reg_tracking[X86PhysicalRegisters::R15.unique_index()] = X86PhysicalRegisters::R15.unique_index();
phys_reg_tracking[X86PhysicalRegisters::BP.unique_index()] = X86PhysicalRegisters::BP.unique_index();
phys_reg_tracking[X86PhysicalRegisters::SP.unique_index()] = X86PhysicalRegisters::SP.unique_index();
Instruction *last = head->prev();
Instruction *current = last;
do {
#ifdef PDEBUG
{
Formatter __debug_formatter;
_support.debug_printf("@ %lu = %s\n", current->nr, __debug_formatter.format_instruction(current));
}
#endif
Instruction::UseDefList usedeflist;
current->get_usedefs(usedeflist);
bool skip = false;
for (unsigned int use_def_index = 0; use_def_index < usedeflist.next; use_def_index++) {
const auto& usedef = usedeflist.get(use_def_index);
if (!usedef.is_valid()) continue; // Skip invalid usedefs
if (!usedef.is_def()) continue; // Skip non-def usedefs
dbt_u64 register_index = usedef.reg.unique_index();
if (usedef.reg.is_virtual()) {
// Definition of VREG
VirtualRegister *vreg = &vregs[register_index];
if (vreg->first_def == current) {
if (vreg->last_use == nullptr) {
#ifdef PDEBUG
_support.debug_printf("def of unused vreg %u\n", register_index);
#endif
skip = true;
break;
} else {
// If this is the first def, then release the allocated vreg
live_phys_regs.clear(vreg->physical_register_index);
#ifdef PDEBUG
_support.debug_printf("ending live-range of vreg %u in preg %u\n", register_index, vreg->physical_register_index);
#endif
}
}
} else {
if (register_index > MAX_PHYS_REGISTERS) {
_support.assertion_fail("definition of invalid preg");
return false;
}
// Definition of PREG
if (live_phys_regs.is_set(register_index)) {
live_phys_regs.clear(register_index);
if (phys_reg_tracking[register_index] > MAX_PHYS_REGISTERS) {
dbt_u64 conflicting_vreg_index = phys_reg_tracking[register_index];
VirtualRegister *conflicting_vreg = &vregs[conflicting_vreg_index];
#ifdef PDEBUG
_support.debug_printf("def of preg %u, but it's tracking vreg %u!\n", register_index, conflicting_vreg_index);
#endif
// Find a new preg for the vreg
dbt_u64 mask = usedef.reg.is_sse() ? SSE_MASK : GPR_MASK;
dbt_u64 new_preg = conflicting_vreg->interference.find_first_clear_via_mask(mask);
if (new_preg == (dbt_u64) - 1) {
#ifdef PDEBUG
_support.debug_printf("vreg %u interference=%08x\n", conflicting_vreg_index, (dbt_u64) conflicting_vreg->interference);
#endif
_support.assertion_fail("out of registers in re-assignment");
}
#ifdef PDEBUG
_support.debug_printf("re-assigning vreg %u to preg %u (%08x)\n", conflicting_vreg_index, new_preg, (dbt_u64) conflicting_vreg->interference);
#endif
conflicting_vreg->physical_register_index = new_preg;
phys_reg_tracking[conflicting_vreg->physical_register_index] = conflicting_vreg_index;
live_phys_regs.set(conflicting_vreg->physical_register_index);
vregs[conflicting_vreg_index].interference = live_phys_regs;
// Update ALL vreg interferences
for (int i = 0; i < MAX_PHYS_REGISTERS; i++) {
if (live_phys_regs.is_set(i)) {
#ifdef PDEBUG
_support.debug_printf(" updating preg=%u, vreg=%u, prev=%08x, cur=%08x\n", i, phys_reg_tracking[i], (dbt_u64) vregs[phys_reg_tracking[i]].interference, (dbt_u64) live_phys_regs);
#endif
vregs[phys_reg_tracking[i]].interference |= live_phys_regs;
}
}
}
#ifdef PDEBUG
_support.debug_printf("ending live-range of preg %u, tracking %u\n", register_index, phys_reg_tracking[register_index]);
#endif
}
}
}
if (!skip) {
for (unsigned int use_def_index = 0; use_def_index < usedeflist.next; use_def_index++) {
const auto& usedef = usedeflist.get(use_def_index);
if (!usedef.is_valid()) continue; // Skip invalid usedefs
if (!usedef.is_use()) continue; // Skip non-use usedefs
dbt_u64 register_index = usedef.reg.unique_index();
if (usedef.reg.is_virtual()) {
// Use of VREG
VirtualRegister *vreg = &vregs[register_index];
if (vreg->last_use == current || vreg->physical_register_index == 32) {
// If this is the last use, then allocate a register to start tracking this vreg
#ifdef PDEBUG
dbt_u64 xxx = (dbt_u64) live_phys_regs;
#endif
// Now, hold the phone. We need to find a register of the correct class.
dbt_u64 mask = usedef.reg.is_sse() ? SSE_MASK : GPR_MASK;
#ifdef CLEVER_ALLOCATION_STRATEGY
// Try to be smart about this
if (current->kind() == InstructionKind::MOV || current->kind() == InstructionKind::MOVZX) {
auto& srcop = current->get_operand(0);
auto& dstop = current->get_operand(1);
if (srcop.is_reg() && srcop.reg.reg.is_virtual() && dstop.is_reg() && !dstop.reg.reg.is_special()) {
if (dstop.reg.reg.is_virtual()) {
#ifdef PDEBUG
_support.debug_printf(" selecting register for mov vreg->vreg instruction\n");
#endif
vreg->physical_register_index = live_phys_regs.find_first_clear_via_mask(mask);
} else {
#ifdef PDEBUG
_support.debug_printf(" selecting register for mov vreg->preg instruction - want preg=%u\n", dstop.reg.reg.unique_index());
#endif
if (live_phys_regs.is_clear(dstop.reg.reg.unique_index())) {
#ifdef PDEBUG
_support.debug_printf(" available!\n", dstop.reg.reg.unique_index());
#endif
vreg->physical_register_index = dstop.reg.reg.unique_index();
} else {
#ifdef PDEBUG
_support.debug_printf(" not available!\n", dstop.reg.reg.unique_index());
#endif
vreg->physical_register_index = live_phys_regs.find_first_clear_via_mask(mask);
}
}
} else {
vreg->physical_register_index = live_phys_regs.find_first_clear_via_mask(mask);
}
} else {
#endif
vreg->physical_register_index = live_phys_regs.find_first_clear_via_mask(mask);
#ifdef CLEVER_ALLOCATION_STRATEGY
}
#endif
if (vreg->physical_register_index < 0) {
_support.assertion_fail("out of registers in allocation");
}
phys_reg_tracking[vreg->physical_register_index] = register_index;
live_phys_regs.set(vreg->physical_register_index);
vregs[register_index].interference = live_phys_regs;
// TODO: Update ALL vreg interferences
for (int i = 0; i < MAX_PHYS_REGISTERS; i++) {
if (live_phys_regs.is_set(i)) {
#ifdef PDEBUG
_support.debug_printf(" updating preg=%u, vreg=%u, prev=%08x, cur=%08x\n", i, phys_reg_tracking[i], (dbt_u64) vregs[phys_reg_tracking[i]].interference, (dbt_u64) live_phys_regs);
#endif
vregs[phys_reg_tracking[i]].interference |= live_phys_regs;
}
}
#ifdef PDEBUG
_support.debug_printf("starting live-range of vreg %u, allocated to preg %u (%08x, %08x)\n", register_index, vreg->physical_register_index, xxx, (dbt_u64) live_phys_regs);
#endif
}
} else {
if (register_index > 32) {
_support.assertion_fail("use of invalid preg");
return false;
}
// Use of PREG
if (live_phys_regs.is_set(register_index) && phys_reg_tracking[register_index] != register_index) {
dbt_u64 conflicting_vreg_index = phys_reg_tracking[register_index];
VirtualRegister *conflicting_vreg = &vregs[conflicting_vreg_index];
#ifdef PDEBUG
_support.debug_printf("conflicting use of preg %u, currently tracking %u\n", register_index, conflicting_vreg_index);
#endif
// Find a new preg for the vreg
dbt_u64 mask = usedef.reg.is_sse() ? SSE_MASK : GPR_MASK;
dbt_u64 new_preg = conflicting_vreg->interference.find_first_clear_via_mask(mask);
if (new_preg == (dbt_u64) - 1) {
#ifdef PDEBUG
_support.debug_printf("vreg %u interference=%08x\n", conflicting_vreg_index, (dbt_u64) conflicting_vreg->interference);
#endif
_support.assertion_fail("out of registers in re-assignment");
}
#ifdef PDEBUG
_support.debug_printf("re-assigning vreg %u to preg %u (%08x)\n", conflicting_vreg_index, new_preg, (dbt_u64) conflicting_vreg->interference);
#endif
conflicting_vreg->physical_register_index = new_preg;
phys_reg_tracking[conflicting_vreg->physical_register_index] = conflicting_vreg_index;
live_phys_regs.set(conflicting_vreg->physical_register_index);
vregs[conflicting_vreg_index].interference = live_phys_regs;
// Update ALL vreg interferences
for (int i = 0; i < MAX_PHYS_REGISTERS; i++) {
if (live_phys_regs.is_set(i)) {
#ifdef PDEBUG
_support.debug_printf(" updating preg=%u, vreg=%u, prev=%08x, cur=%08x\n", i, phys_reg_tracking[i], (dbt_u64) vregs[phys_reg_tracking[i]].interference, (dbt_u64) live_phys_regs);
#endif
vregs[phys_reg_tracking[i]].interference |= live_phys_regs;
}
}
phys_reg_tracking[register_index] = register_index;
} else {
phys_reg_tracking[register_index] = register_index;
live_phys_regs.set(register_index);
vregs[register_index].interference = live_phys_regs;
// Update ALL vreg interferences
for (int i = 0; i < MAX_PHYS_REGISTERS; i++) {
if (live_phys_regs.is_set(i)) {
#ifdef PDEBUG
_support.debug_printf(" updating preg=%u, vreg=%u, prev=%08x, cur=%08x\n", i, phys_reg_tracking[i], (dbt_u64) vregs[phys_reg_tracking[i]].interference, (dbt_u64) live_phys_regs);
#endif
vregs[phys_reg_tracking[i]].interference |= live_phys_regs;
}
}
#ifdef PDEBUG
_support.debug_printf("starting live-range of preg %u (%08x)\n", register_index, (dbt_u64) live_phys_regs);
#endif
}
}
}
}
current = current->prev();
} while (current != last);
return true;
}
bool ReverseAllocator::commit(Instruction* head, const VirtualRegister* vreg_to_preg)
{
static const X86PhysicalRegister * assignments[] = {
&X86PhysicalRegisters::A,
&X86PhysicalRegisters::C,
&X86PhysicalRegisters::D,
&X86PhysicalRegisters::B,
&X86PhysicalRegisters::RIZ,
&X86PhysicalRegisters::RIZ,
&X86PhysicalRegisters::SI,
&X86PhysicalRegisters::DI,
&X86PhysicalRegisters::R8,
&X86PhysicalRegisters::R9,
&X86PhysicalRegisters::R10,
&X86PhysicalRegisters::R11,
&X86PhysicalRegisters::R12,
&X86PhysicalRegisters::R13,
&X86PhysicalRegisters::R14,
&X86PhysicalRegisters::R15,
&X86PhysicalRegisters::XMM0,
&X86PhysicalRegisters::XMM1,
&X86PhysicalRegisters::XMM2,
&X86PhysicalRegisters::XMM3,
&X86PhysicalRegisters::XMM4,
&X86PhysicalRegisters::XMM5,
&X86PhysicalRegisters::XMM6,
&X86PhysicalRegisters::XMM7,
};
Instruction *current = head;
do {
if (current->kind() != InstructionKind::DEAD) {
for (unsigned int i = 0; i < Instruction::NR_OPERANDS; i++) {
const auto& operand = current->get_operand(i);
if (operand.is_reg()) {
if (operand.reg.reg.is_virtual()) {
dbt_u64 preg_index = vreg_to_preg[operand.reg.reg.unique_index()].physical_register_index;
if (preg_index == X86PhysicalRegisters::RIZ.unique_index()) {
current->change_kind(InstructionKind::DEAD);
break;
}
if (preg_index >= (sizeof(assignments) / sizeof(assignments[0]))) {
#ifdef PDEBUG
_support.debug_printf("illegal vreg %u to preg %u @ %u (reg operand)\n", operand.reg.reg.unique_index(), preg_index, current->nr);
#endif
_support.assertion_fail("assignment of preg out of range");
}
#ifdef PDEBUG
_support.debug_printf("committing vreg %u to preg %u @ %u (reg operand)\n", operand.reg.reg.unique_index(), preg_index, current->nr);
#endif
current->get_operand_nc(i).reg.reg = *assignments[preg_index];
}
} else if (operand.is_mem()) {
if (operand.mem.base_register.is_virtual()) {
dbt_u64 preg_index = vreg_to_preg[operand.mem.base_register.unique_index()].physical_register_index;
if (preg_index >= (sizeof(assignments) / sizeof(assignments[0]))) {
_support.assertion_fail("assignment of preg out of range");
}
#ifdef PDEBUG
_support.debug_printf("committing vreg %u to preg %u @ %u (mem base operand)\n", operand.reg.reg.unique_index(), preg_index, current->nr);
#endif
current->get_operand_nc(i).mem.base_register = *assignments[preg_index];
}
if (operand.mem.index_register.is_virtual()) {
dbt_u64 preg_index = vreg_to_preg[operand.mem.index_register.unique_index()].physical_register_index;
if (preg_index >= (sizeof(assignments) / sizeof(assignments[0]))) {
_support.assertion_fail("assignment of preg out of range");
}
#ifdef PDEBUG
_support.debug_printf("committing vreg %u to preg %u @ %u (mem idx operand)\n", operand.reg.reg.unique_index(), preg_index, current->nr);
#endif
current->get_operand_nc(i).mem.index_register = *assignments[preg_index];
}
}
}
}
switch (current->kind()) {
case InstructionKind::MOV:
case InstructionKind::MOVQ:
case InstructionKind::MOVDQA:
if (current->get_operand(0) == current->get_operand(1)) {
current->change_kind(InstructionKind::DEAD);
}
break;
default:
break;
}
current = current->next();
} while (current != head);
return true;
}
bool ReverseAllocator::verify(const Instruction* head)
{
const Instruction *current = head;
do {
#ifndef PDEBUG
if (!verify_instruction(current)) {
#endif
Formatter __fmt;
_support.debug_printf("[%u] %s\n", current->nr, __fmt.format_instruction(current));
#ifndef PDEBUG
return false;
}
#endif
current = current->next();
} while (current != head);
return true;
}
bool ReverseAllocator::verify_instruction(const Instruction* insn)
{
if (insn->kind() == InstructionKind::DEAD) return true;
for (int i = 0; i < Instruction::NR_OPERANDS; i++) {
auto op = insn->get_operand(0);
if (op.is_reg()) {
if (op.reg.reg.is_virtual()) {
_support.debug_printf("verification failed: instruction has virtual register operand\n");
return false;
}
} else if (op.is_mem()) {
if (op.mem.base_register.is_virtual()) {
_support.debug_printf("verification failed: instruction has virtual base register operand\n");
return false;
}
if (op.mem.index_register.is_virtual()) {
_support.debug_printf("verification failed: instruction has virtual index register operand\n");
return false;
}
}
}
return true;
}
bool ReverseAllocator::decorate_call(Instruction *call_instruction, int nr_args)
{
static const X86PhysicalRegister * caller_saved[] = {
// Caller Saved
&X86PhysicalRegisters::A,
&X86PhysicalRegisters::R10,
&X86PhysicalRegisters::R11,
// Function Arguments
&X86PhysicalRegisters::R9,
&X86PhysicalRegisters::R8,
&X86PhysicalRegisters::C,
&X86PhysicalRegisters::D,
&X86PhysicalRegisters::SI,
&X86PhysicalRegisters::DI
};
for (int i = 0; i < (3 + (6 - nr_args)); i++) {
auto reg = caller_saved[i];
auto push = _support.alloc_obj<Instruction>(InstructionKind::PUSH);
auto pop = _support.alloc_obj<Instruction>(InstructionKind::POP);
push->set_operand(0, Operand::make_register(*reg, 64));
pop->set_operand(0, Operand::make_register(*reg, 64));
call_instruction->prev()->insert_after(push);
call_instruction->insert_after(pop);
}
return true;
}
bool ReverseAllocator::fixup_calls(Instruction *head)
{
Instruction *current = head;
do {
switch (current->kind()) {
case InstructionKind::CALL:
case InstructionKind::CALL0:
case InstructionKind::CALL1:
case InstructionKind::CALL2:
case InstructionKind::CALL3:
case InstructionKind::CALL4:
case InstructionKind::CALL5:
case InstructionKind::CALL6:
if (!decorate_call(current, 0)) {
return false;
}
break;
default: break;
}
current = current->next();
} while (current != head);
return true;
}
bool ReverseAllocator::number_and_legalise_instructions(Instruction *head)
{
dbt_u64 idx = 0;
Instruction *current = head;
do {
// Number the instruction.
current->nr = idx++;
// Any mem -> mem instructions must be performed via a temporary register
if (current->match2() == InstructionMatch::MEM_MEM) {
auto op0 = current->get_operand(0);
// auto op1 = current->get_operand(1);
auto tmp = Operand::make_register(_vreg_allocator.alloc_vreg(X86RegisterClasses::GENERAL_PURPOSE), op0.mem.access_width);
auto mov_to_tmp = _support.alloc_obj<Instruction>(InstructionKind::MOV);
mov_to_tmp->set_operand(0, op0);
mov_to_tmp->set_operand(1, tmp);
current->prev()->insert_after(mov_to_tmp);
current->set_operand(0, tmp);
mov_to_tmp->nr = current->nr;
current->nr = idx++;
} else if (current->kind() == InstructionKind::JMP) {
if (current->get_operand(0).label.target == current->next()) {
current->change_kind(InstructionKind::DEAD);
}
}
#ifdef PDEBUG
{
Formatter __fmt;
_support.debug_printf("[%u] %s\n", current->nr, __fmt.format_instruction(current));
}
#endif
current = current->next();
} while (current != head);
return true;
} | 24,731 | 10,706 |
#include <stack>
#include <cmath>
#include "geneticalgorithm/binarygenome.h"
#include "geneticalgorithm/genalg.h"
int genomeValue(const ga::BinaryGenome& genome)
{
auto decoded = genome.decode(4);
std::stack<int> values;
for (unsigned i = 0; i < decoded.size(); ++i)
{
unsigned d = decoded[i];
if (d <= 9)
values.push(d);
else if (d >= 13)
continue;
else if (values.size() >= 2)
{
int a = values.top(); values.pop();
int b = values.top(); values.pop();
if (d == 10) // Sum
values.push(b + a);
else if (d == 11) // Difference
values.push(b - a);
else if (d == 12) // Multiplication
values.push(a * b);
}
}
if (values.size() == 0)
return 0;
return values.top();
}
double fitnessFunc(ga::BinaryGenome& genome)
{
return 1.0 / (double)(exp(abs(genomeValue(genome) - 42) / 21.0));
}
void printGenome(const ga::BinaryGenome& genome)
{
auto decoded = genome.decode(4);
for (unsigned i = 0; i < decoded.size(); ++i)
{
int d = decoded[i];
if (d <= 9)
printf("%d ", d);
else if (d >= 13)
printf("x ");
else
{
if (d == 10) // Sum
printf("+ ");
else if (d == 11) // Difference
printf("- ");
else if (d == 12) // Multiplication
printf("* ");
}
}
printf(" | ");
for (unsigned i = 0; i < 32; ++i)
printf("%d", genome.extract()[i]);
printf("\n");
}
int main(int argc, char** argv)
{
int population_size = 20, generations = 100;
unsigned elite = 2;
double mutation = 0.01, crossover = 0.7;
if (argc > 1)
population_size = atoi(argv[1]);
if (argc > 2)
generations = atoi(argv[2]);
if (argc > 3)
elite = atoi(argv[3]);
if (argc > 4)
mutation = atof(argv[4]);
if (argc > 5)
crossover = atof(argv[5]);
ga::GeneticAlgorithm<ga::BinaryGenome> evolution (population_size, 32, elite, mutation, crossover, fitnessFunc);
for (int i = 0; i < generations; ++i)
{
if (i > 0) evolution.epoch();
printf("generation %d:\n", evolution.generation());
printf("best:\n %d %.2f: ", genomeValue(evolution.get_best_of_all()), evolution.get_best_of_all().getFitness());
printGenome(evolution.get_best_of_all());
printf("\n");
auto population = evolution.population();
for (unsigned j = 0; j < population.size(); ++j)
{
printf("%3d %3d %1.2f: ", j, genomeValue(population[j]), population[j].getFitness());
printGenome(population[j]);
}
printf("\n");
}
printf("Best of all: %d\n", genomeValue(evolution.get_best_of_all()));
return 0;
}
| 2,630 | 1,051 |
#ifndef TIMER_HPP
#define TIMER_HPP
class Timer {
public:
Timer(float sampleRate)
: _ticks(0),
_seconds(0.0),
_sampleRate(sampleRate)
{}
float seconds() const {
return _seconds;
}
unsigned long int ticks() const {
return _ticks;
}
void update(const float &sampleRate) {
_seconds = _ticks++ / sampleRate;
}
const float & sampleRate() const {
return _sampleRate;
}
private:
unsigned long int _ticks;
float _seconds;
const float _sampleRate;
};
#endif
| 506 | 216 |
#include "metadata/parquet_metadata.h"
#include "ParquetParser.h"
#include "config/GPUManager.cuh"
#include <blazingdb/io/Util/StringUtil.h>
#include "utilities/CommonOperations.h"
#include <algorithm>
#include <string>
#include <unordered_map>
#include <vector>
#include <memory>
#include <algorithm>
#include <numeric>
#include <string>
#include <iostream>
#include <cudf/cudf.h>
#include <cudf/io/functions.hpp>
#include <unordered_map>
#include <vector>
#include <arrow/io/file.h>
#include <parquet/file_reader.h>
#include <parquet/schema.h>
#include <parquet/types.h>
#include <thread>
#include <parquet/column_writer.h>
#include <parquet/file_writer.h>
#include <parquet/properties.h>
#include <parquet/schema.h>
#include <parquet/types.h>
#include <parquet/api/reader.h>
#include <parquet/api/writer.h>
#include "../Schema.h"
#include <numeric>
namespace ral {
namespace io {
namespace cudf_io = cudf::experimental::io;
parquet_parser::parquet_parser() {
// TODO Auto-generated constructor stub
}
parquet_parser::~parquet_parser() {
// TODO Auto-generated destructor stub
}
std::unique_ptr<ral::frame::BlazingTable> parquet_parser::parse(
std::shared_ptr<arrow::io::RandomAccessFile> file,
const std::string & user_readable_file_handle,
const Schema & schema,
std::vector<size_t> column_indices)
{
if(file == nullptr) {
return schema.makeEmptyBlazingTable(column_indices);
}
if(column_indices.size() > 0) {
// Fill data to pq_args
cudf_io::read_parquet_args pq_args{cudf_io::source_info{file}};
pq_args.strings_to_categorical = false;
pq_args.columns.resize(column_indices.size());
for(size_t column_i = 0; column_i < column_indices.size(); column_i++) {
pq_args.columns[column_i] = schema.get_name(column_indices[column_i]);
}
std::vector<int> row_groups = schema.get_rowgroup_ids(0); // because the Schema we are using here was already filtered for a specific file by Schema::fileSchema we are simply getting the first set of rowgroup_ids
if (row_groups.size() == 0){
// make empty table of the right schema
return schema.makeEmptyBlazingTable(column_indices);
} else {
// now lets get these row_groups in batches of consecutive rowgroups because that is how the reader will want them
std::vector<int> consecutive_row_group_start(1, row_groups[0]);
std::vector<int> consecutive_row_group_length;
int length_count = 1;
int last_rowgroup = consecutive_row_group_start.back();
for (int i = 1; i < row_groups.size(); i++){
if (last_rowgroup + 1 == row_groups[i]){ // consecutive
length_count++;
last_rowgroup = row_groups[i];
} else {
consecutive_row_group_length.push_back(length_count);
consecutive_row_group_start.push_back(row_groups[i]);
last_rowgroup = row_groups[i];
length_count = 1;
}
}
consecutive_row_group_length.push_back(length_count);
if (consecutive_row_group_start.size() == 1){
pq_args.row_group = consecutive_row_group_start[0];
pq_args.row_group_count = consecutive_row_group_length[0];
auto result = cudf_io::read_parquet(pq_args);
if (result.tbl->num_columns() == 0){
return schema.makeEmptyBlazingTable(column_indices);
}
return std::make_unique<ral::frame::BlazingTable>(std::move(result.tbl), result.metadata.column_names);
} else {
std::vector<std::unique_ptr<ral::frame::BlazingTable>> table_outs;
std::vector<ral::frame::BlazingTableView> table_view_outs;
for (int i = 0; i < consecutive_row_group_start.size(); i++){
pq_args.row_group = consecutive_row_group_start[i];
pq_args.row_group_count = consecutive_row_group_length[i];
auto result = cudf_io::read_parquet(pq_args);
if (result.tbl->num_columns() == 0){
return schema.makeEmptyBlazingTable(column_indices);
}
table_outs.emplace_back(std::make_unique<ral::frame::BlazingTable>(std::move(result.tbl), result.metadata.column_names));
table_view_outs.emplace_back(table_outs.back()->toBlazingTableView());
}
return ral::utilities::experimental::concatTables(table_view_outs);
}
}
}
return nullptr;
}
void parquet_parser::parse_schema(
std::vector<std::shared_ptr<arrow::io::RandomAccessFile>> files, ral::io::Schema & schema) {
cudf_io::table_with_metadata table_out;
for (auto file : files) {
auto parquet_reader = parquet::ParquetFileReader::Open(file);
if (parquet_reader->metadata()->num_rows() == 0) {
parquet_reader->Close();
continue;
}
cudf_io::read_parquet_args pq_args{cudf_io::source_info{file}};
pq_args.strings_to_categorical = false;
pq_args.row_group = 0;
pq_args.num_rows = 1;
table_out = cudf_io::read_parquet(pq_args);
if (table_out.tbl->num_columns() > 0) {
break;
}
}
assert(table_out.tbl->num_columns() > 0);
for(size_t i = 0; i < table_out.tbl->num_columns(); i++) {
cudf::type_id type = table_out.tbl->get_column(i).type().id();
size_t file_index = i;
bool is_in_file = true;
std::string name = table_out.metadata.column_names.at(i);
schema.add_column(name, type, file_index, is_in_file);
}
}
std::unique_ptr<ral::frame::BlazingTable> parquet_parser::get_metadata(std::vector<std::shared_ptr<arrow::io::RandomAccessFile>> files, int offset){
std::vector<size_t> num_row_groups(files.size());
std::thread threads[files.size()];
std::vector<std::unique_ptr<parquet::ParquetFileReader>> parquet_readers(files.size());
for(int file_index = 0; file_index < files.size(); file_index++) {
threads[file_index] = std::thread([&, file_index]() {
parquet_readers[file_index] =
std::move(parquet::ParquetFileReader::Open(files[file_index]));
std::shared_ptr<parquet::FileMetaData> file_metadata = parquet_readers[file_index]->metadata();
const parquet::SchemaDescriptor * schema = file_metadata->schema();
num_row_groups[file_index] = file_metadata->num_row_groups();
});
}
for(int file_index = 0; file_index < files.size(); file_index++) {
threads[file_index].join();
}
size_t total_num_row_groups =
std::accumulate(num_row_groups.begin(), num_row_groups.end(), size_t(0));
auto minmax_metadata_table = get_minmax_metadata(parquet_readers, total_num_row_groups, offset);
for (auto &reader : parquet_readers) {
reader->Close();
}
return std::move(minmax_metadata_table);
}
} /* namespace io */
} /* namespace ral */
| 6,350 | 2,507 |
/*
Copyright 2010 OpenRTMFP
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License received along this program for more
details (or else see http://www.gnu.org/licenses/).
This file is a part of Cumulus.
*/
#include "LUAAMFObjectWriter.h"
#include "AMFObjectWriter.h"
using namespace Cumulus;
const char* LUAAMFObjectWriter::Name="Cumulus::AMFObjectWriter";
int LUAAMFObjectWriter::Get(lua_State *pState) {
SCRIPT_CALLBACK(AMFObjectWriter,LUAAMFObjectWriter,writer)
SCRIPT_READ_STRING(name,"")
if(name=="write")
SCRIPT_WRITE_FUNCTION(&LUAAMFObjectWriter::Write)
SCRIPT_CALLBACK_RETURN
}
int LUAAMFObjectWriter::Set(lua_State *pState) {
SCRIPT_CALLBACK(AMFObjectWriter,LUAAMFObjectWriter,writer)
SCRIPT_READ_STRING(name,"")
lua_rawset(pState,1); // consumes key and value
SCRIPT_CALLBACK_RETURN
}
int LUAAMFObjectWriter::Write(lua_State* pState) {
SCRIPT_CALLBACK(AMFObjectWriter,LUAAMFObjectWriter,writer)
SCRIPT_READ_STRING(name,"")
if(SCRIPT_CAN_READ) {
writer.writer.writePropertyName(name);
Script::ReadAMF(pState,writer.writer,1);
} else
SCRIPT_ERROR("This function takes 2 parameters: name and value")
SCRIPT_CALLBACK_RETURN
}
| 1,610 | 597 |
/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
/* -*-C++-*-
**************************************************************************
*
* File: NAError.C
* Description: New Architecture Error Handler
* Created: 01/24/95
* Language: C++
*
*
*
**************************************************************************
*/
#include "NAError.h"
#include <iostream>
// -----------------------------------------------------------------------
// NAErrorParamArray
// -----------------------------------------------------------------------
NAErrorParamArray::NAErrorParamArray
(Lng32 numParams,
NAErrorParam * errParam1,NAErrorParam * errParam2,
NAErrorParam * errParam3,NAErrorParam * errParam4,
NAErrorParam * errParam5,NAErrorParam * errParam6,
NAErrorParam * errParam7,NAErrorParam * errParam8,
NAErrorParam * errParam9,NAErrorParam * errParam10)
: numParams_(numParams)
{
array_ = new NAErrorParamArrayElement[numParams];
NAErrorParam * errParamPtr;
for (Lng32 index = 0; index < numParams; index ++)
{
if (index == 0) errParamPtr = errParam1;
else if (index == 1) errParamPtr = errParam2;
else if (index == 2) errParamPtr = errParam3;
else if (index == 3) errParamPtr = errParam4;
else if (index == 4) errParamPtr = errParam5;
else if (index == 5) errParamPtr = errParam6;
else if (index == 6) errParamPtr = errParam7;
else if (index == 7) errParamPtr = errParam8;
else if (index == 8) errParamPtr = errParam9;
else if (index == 9) errParamPtr = errParam10;
array_[index].errParam_ = errParamPtr;
}
} // NAErrorParamArray::NAErrorParamArray()
NAErrorParamArray::~NAErrorParamArray (void)
{
for (Int32 index=0; index<entries(); index++)
{
if (array_[index].errParam_ != 0) delete array_[index].errParam_;
};
delete array_;
};
// -----------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------
NAError::NAError(const NAErrorCode errCode,
const NAErrorType errType,
const NASubsys subsys,
NAErrorParamArray * errParams,
char * procName,
const ULng32 lineNumber,
const ULng32 offset
)
: errCode_(errCode), errType_(errType), subsysId_(subsys),
procName_(procName),
#pragma nowarn(1506) // warning elimination
lineNumber_(lineNumber), offset_(offset), next_(0)
#pragma warn(1506) // warning elimination
{
errParams_ = errParams;
}
NAError::~NAError()
{
if (errParams_)
delete errParams_;
if (procName_ )
delete procName_;
} // NAError::~NAError()
NAErrorStack::~NAErrorStack()
{
NAErrorStack::clear();
} // NAErrorStack::~NAErrorStack()
void NAErrorStack::clear()
{
NAError * errorPtr = errEntry_;
NAError * nextPtr;
while (errorPtr)
{
nextPtr = errorPtr->getNext();
delete errorPtr;
errorPtr = nextPtr;
}
errEntry_ = 0;
nextEntry_ = errEntry_;
numEntries_ = 0;
} // NAErrorStack::clear
void NAErrorStack::addErrEntry(NAError * errPtr)
{
if (numEntries_ <= maxEntries_)
{
errPtr->setNext(errEntry_);
errEntry_ = errPtr;
numEntries_++;
}
else
; // I believe SQL2 wants us to issue an error here.
} // NAErrorStack::addErrEntry()
NAError * NAErrorStack::getNext()
{
if (iterEntries_ <= numEntries_)
{
iterEntries_++;
NAError * ne = nextEntry_;
if (nextEntry_ != 0)
nextEntry_ = nextEntry_->getNext(); // init with -> to follower
return ne;
}
else
return 0;
} // NAErrorStack::getNext()
NAError * NAErrorStack::getFirst()
{
nextEntry_ = errEntry_;
iterEntries_ = 0;
return getNext();
} // NAErrorStack::getFirst()
| 4,764 | 1,475 |