instruction
stringlengths 27
1.88k
| output
stringlengths 21
2.78k
|
|---|---|
void pmInitComplete(void)
{
if (((earlyTopology != 0) && (pmDispatch != (code **)0x0)) && (*pmDispatch != (code *)0x0)) {
(**pmDispatch)();
earlyTopology = FALSE;
pmInitDone = 1;
return;
}
pmInitDone = 1;
return;
}
|
void
pmInitComplete(void)
{
if (earlyTopology
&& pmDispatch != NULL
&& pmDispatch->pmCPUStateInit != NULL) {
(*pmDispatch->pmCPUStateInit)();
earlyTopology = FALSE;
}
pmInitDone = 1;
}
|
int newload(long param_1,int param_2)
{
undefined *puVar1;
int iVar2;
long lVar3;
j_1928 = 0;
if (param_2 == 0) {
iVar2 = -1;
}
else {
do {
if (Incnt < 1) {
Incnt = read(Fd,Cpmbuf,(ulong)Cpbufsize);
Cpindex = 0;
if (Incnt < 1) break;
}
puVar1 = (undefined *)((long)Cpmbuf + Cpindex);
lVar3 = (long)j_1928;
j_1928 = j_1928 + 1;
Cpindex = Cpindex + 1;
*(undefined *)(param_1 + lVar3) = *puVar1;
Incnt = Incnt + -1;
param_2 = param_2 + -1;
} while (param_2 != 0);
iVar2 = j_1928;
if (j_1928 == 0) {
iVar2 = -1;
}
}
return iVar2;
}
|
int newload ( char * buf, int count )
{
static int j;
j = 0;
while ( count-- ) {
if ( Incnt <= 0 ) {
Incnt = read ( Fd, Cpmbuf, Cpbufsize );
Cpindex = 0;
if ( Incnt <= 0 )
break;
}
buf[j++] = Cpmbuf[Cpindex++];
--Incnt;
}
return ( j ? j : -1 );
}
|
undefined8 luaS_newlstr(undefined8 param_1,void *param_2,ulong param_3)
{
uint uVar1;
undefined8 uVar2;
if (LUAI_MAXSHORTLEN < param_3) {
if ((long)MAX_SIZE - 4U <= param_3) {
luaM_toobig(param_1);
}
uVar2 = luaS_createlngstrobj(param_1,param_3);
uVar1 = getstr(uVar2);
memcpy((void *)(ulong)uVar1,param_2,param_3);
}
else {
uVar2 = internshrstr(param_1,param_2,param_3);
}
return uVar2;
}
|
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
if (l <= LUAI_MAXSHORTLEN) /* short string? */
return internshrstr(L, str, l);
else {
TString *ts;
if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
luaM_toobig(L);
ts = luaS_createlngstrobj(L, l);
memcpy(getstr(ts), str, l * sizeof(char));
return ts;
}
}
|
bool SDP_SetEncryptionKey
(long param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4,
undefined8 param_5,undefined8 param_6)
{
long lVar1;
char *pcVar2;
if (param_1 == 0) {
SDP_AssertionFailed("\"%s\" is NULL, and it shouldn\'t be. (Assertion failed at line %d from %s.)"
,"encryption",0x408,
"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/jcable/mcl/refs/heads/master/src/sdp_lib/src/SDP_Description.c"
,param_5,param_6,param_2);
}
lVar1 = SDP_CopyToStr(param_1,param_2);
if (lVar1 == 0) {
pcVar2 = strerror(errno);
SDP_RaiseFatalError(SDP_ERR_OUT_OF_MEMORY,"Couldn\'t allocate memory to copy string: %s.",
(ulong)pcVar2 & 0xffffffff);
}
return lVar1 != 0;
}
|
int SDP_SetEncryptionKey(
SDP_Encryption * encryption,
const char * key)
{
((encryption == NULL) ? SDP_AssertionFailed( "\"%s\" is NULL, and it shouldn't be. " "(Assertion failed at line %d from %s.)", "encryption", 1032, "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/jcable/mcl/refs/heads/master/src/sdp_lib/src/SDP_Description.c" ) : (void) 0);
do { if (((SDP_CopyToStr(&encryption->key, key)) ? 0 : 1)) { SDP_RaiseFatalError( SDP_ERR_OUT_OF_MEMORY, "Couldn't allocate memory to copy string: " "%s.", (strerror(errno)) ); return 0; } } while (0);
return 1;
}
|
void i_escape(void)
{
undefined4 uVar1;
uVar1 = FETCH_B();
GetModRMRMB(uVar1);
return;
}
|
void i_escape(void)
{
GetModRMRMB(FETCH_B());
}
|
void bubbleSort(long param_1,uint param_2)
{
undefined4 uVar1;
int local_14;
int local_10;
printf("size %d\n",(ulong)param_2);
if (1 < (int)param_2) {
for (local_14 = 0; local_14 < (int)(param_2 - 1); local_14 = local_14 + 1) {
for (local_10 = 0; local_10 < (int)((param_2 - 1) - local_14); local_10 = local_10 + 1) {
if (*(int *)(param_1 + ((long)local_10 + 1) * 4) < *(int *)(param_1 + (long)local_10 * 4)) {
uVar1 = *(undefined4 *)(param_1 + (long)local_10 * 4);
*(undefined4 *)(param_1 + (long)local_10 * 4) =
*(undefined4 *)(param_1 + ((long)local_10 + 1) * 4);
*(undefined4 *)(((long)local_10 + 1) * 4 + param_1) = uVar1;
}
}
}
printA(param_1,param_2);
}
return;
}
|
void bubbleSort(int *a,int n) {
int t;
printf("size %d\n",n);
if(n <=1) {
return;
}
for (int i=0; i < n-1; i++){
for(int j=0; j < n-1-i; j++){
if (a[j] > a[j+1]) {
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
printA(a,n);
}
|
void poset__POSetElement__smallers(long **param_1)
{
/* WARNING: Could not recover jumptable at 0x00100011. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(**param_1 + COLOR_poset__POSetElement__froms * 8))();
return;
}
|
val* poset__POSetElement__smallers(val* self) {
val* var ;
val* var1 ;
var1 = ((val* (*)(val*))(self->class->vft[COLOR_poset__POSetElement__froms]))(self) ;
var = var1;
goto RET_LABEL;
RET_LABEL:;
return var;
}
|
logr_err_(undefined8 param_1,undefined4 param_2,undefined8 param_3,undefined8 param_4,
undefined8 param_5)
{
undefined4 uVar1;
va_start(0,param_5);
uVar1 = logr_vxprintf(param_1,param_2,param_3,param_4,&logr,3,param_5,0);
va_end(0);
return uVar1;
}
|
int
logr_err_(const char *file, int line, const char *func, const char *pretty_func, const char *fmt, ...)
{
va_list ap;
int n = 0;
va_start(ap, fmt);
n += logr_vxprintf(file, line, func, pretty_func, &logr, 3, fmt, ap);
va_end(ap);
return n;
}
|
undefined8 * findclient(long *param_1)
{
undefined8 *local_10;
if (clientlist != (undefined8 *)0x0) {
for (local_10 = clientlist; local_10 != (undefined8 *)0x0; local_10 = (undefined8 *)*local_10) {
if ((*param_1 == local_10[1]) && (param_1[1] == local_10[2])) {
return local_10;
}
}
}
return (undefined8 *)0x0;
}
|
Client * findclient( struct sockaddr_in *sinp ) {
Client *cl;
if (clientlist == NULL) return( NULL );
cl = clientlist;
while ( cl != NULL ) {
if (sinp->sin_port == cl->sin.sin_port &&
sinp->sin_addr.s_addr == cl->sin.sin_addr.s_addr)
return( cl );
cl = cl->next;
}
return( NULL );
}
|
void uc4_vertex(void)
{
rsp_vertex(0,(rdp >> 4 & 0xfffU) / 0x21 + 1);
return;
}
|
void uc4_vertex()
{
int v0 = 0;
int n = ((rdp.cmd0 >> 4) & 0xFFF) / 33 + 1;
rsp_vertex(v0, n);
}
|
void strings_split_by_string_up_to(void)
{
strings_split_by_string_up_to_imp();
return;
}
|
List * strings_split_by_string_up_to(char * string, char * split, unsigned int count)
{
return strings_split_by_string_up_to_imp(string, split, count, strings_bounded_equals);
}
|
void bfa_ioc_hb_monitor(long param_1)
{
undefined4 uVar1;
undefined4 uVar2;
long lVar3;
uVar2 = readl(*(undefined4 *)(param_1 + 4));
uVar1 = BFA_IOC_HB_TOV;
*(undefined4 *)(param_1 + 8) = uVar2;
lVar3 = msecs_to_jiffies(uVar1);
mod_timer(param_1,lVar3 + jiffies);
return;
}
|
void
bfa_ioc_hb_monitor(struct bfa_ioc *ioc)
{
ioc->hb_count = readl(ioc->ioc_regs.heartbeat);
mod_timer(&ioc->hb_timer, jiffies +
msecs_to_jiffies(BFA_IOC_HB_TOV));
}
|
void _mesa_WindowPos3ivMESA(ulong *param_1)
{
_mesa_WindowPos4fMESA
(DAT_00100048,*param_1 & 0xffffffff,param_1[1] & 0xffffffff,param_1[2] & 0xffffffff);
return;
}
|
void
_mesa_WindowPos3ivMESA(const GLint *v)
{
_mesa_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
}
|
void strbuf_clear(undefined8 *param_1)
{
*param_1 = 0;
return;
}
|
void strbuf_clear(StrBuf *sb)
{
sb->size = 0;
}
|
void _ThreadRoutine(long param_1)
{
long lVar1;
undefined4 uVar2;
undefined8 *puVar3;
param_1 = param_1 * 0x10;
while( true ) {
pthread_mutex_lock((pthread_mutex_t *)&mutex);
lVar1 = *(long *)(threads_data + param_1);
while (lVar1 == 0) {
if (destroy_threads != 0) goto LAB_00100067;
pthread_cond_wait((pthread_cond_t *)&cond_start,(pthread_mutex_t *)&mutex);
lVar1 = *(long *)(threads_data + param_1);
}
if (destroy_threads != 0) break;
pthread_mutex_unlock((pthread_mutex_t *)&mutex);
lVar1 = *(long *)(threads_data + 8 + param_1);
uVar2 = (**(code **)(lVar1 + 8))(*(undefined4 *)(lVar1 + 4));
*(undefined4 *)(lVar1 + 0x10) = uVar2;
pthread_mutex_lock((pthread_mutex_t *)&mutex);
puVar3 = (undefined8 *)(threads_data + param_1);
*(undefined4 *)puVar3[1] = 1;
*puVar3 = 0;
pthread_cond_broadcast((pthread_cond_t *)&cond_end);
pthread_mutex_unlock((pthread_mutex_t *)&mutex);
}
LAB_00100067:
pthread_mutex_unlock((pthread_mutex_t *)&mutex);
/* WARNING: Subroutine does not return */
pthread_exit((void *)0x0);
}
|
void* _ThreadRoutine(void* thread_index) {
size_t index = (size_t)thread_index;
while (1) {
pthread_mutex_lock(&mutex);
while (!threads_data[index].is_running && !destroy_threads) {
pthread_cond_wait(&cond_start, &mutex);
}
if (destroy_threads) {
pthread_mutex_unlock(&mutex);
break;
}
pthread_mutex_unlock(&mutex);
threads_data[index].task->result =
threads_data[index].task->routine(threads_data[index].task->arg);
pthread_mutex_lock(&mutex);
threads_data[index].task->processed = 1;
threads_data[index].is_running = 0;
pthread_cond_broadcast(&cond_end);
pthread_mutex_unlock(&mutex);
}
pthread_exit(NULL);
}
|
undefined8 n_java_lang_System_identityHashCode(void)
{
return 0xffffffff;
}
|
int16 n_java_lang_System_identityHashCode(int32 *sp) {
return -1;
}
|
undefined4 Ada_lc_TELEPHONE(void)
{
undefined4 uVar1;
uVar1 = lc_TELEPHONE();
return uVar1;
}
|
int Ada_lc_TELEPHONE ()
{
int jresult;
int result;
result = (int) lc_TELEPHONE ();
jresult = result;
return jresult;
}
|
void lo_arg_host_endian(uint param_1,uint *param_2)
{
uint uVar1;
switch(param_1) {
case 0x80:
case 0x82:
case 0x83:
case 0x84:
case 0x85:
case 0x88:
case 0x8a:
goto switchD_0010001e_caseD_80;
case 0x81:
case 0x86:
case 0x8b:
uVar1 = lo_swap64(*param_2);
*param_2 = uVar1;
return;
case 0x87:
case 0x89:
case 0x8c:
case 0x8d:
uVar1 = *param_2;
*param_2 = (int)uVar1 >> 8 & 0xff00U |
uVar1 << 0x18 | (int)uVar1 >> 0x18 | (uVar1 & 0xff00) << 8;
switchD_0010001e_caseD_80:
return;
default:
fprintf((FILE *)(ulong)stderr,"liblo warning: unhandled OSC type \'%c\' at %s:%d\n",
(ulong)param_1,
"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/jeremywrnr/life-of-the-party/refs/heads/main/LED-control/firmware/libraries/liblo/message.c"
,0x295);
return;
}
}
|
void lo_arg_host_endian(lo_type type, void *data)
{
switch (type) {
case LO_INT32:
case LO_FLOAT:
case LO_BLOB:
case LO_CHAR:
*(int32_t *)data = ({ uint32_t __x = (*(int32_t *)data); ((uint32_t)( (((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) | (((uint32_t)(__x) & (uint32_t)0x0000ff00UL) << 8) | (((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >> 8) | (((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) )); });
break;
case LO_INT64:
case LO_TIMETAG:
case LO_DOUBLE:
*(int64_t *)data = lo_swap64(*(int64_t *)data);
break;
case LO_STRING:
case LO_SYMBOL:
case LO_MIDI:
case LO_TRUE:
case LO_FALSE:
case LO_NIL:
case LO_INFINITUM:
break;
default:
fprintf(stderr, "liblo warning: unhandled OSC type '%c' at %s:%d\n",
type, "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/jeremywrnr/life-of-the-party/refs/heads/main/LED-control/firmware/libraries/liblo/message.c", 661);
break;
}
}
|
undefined8 setup(void)
{
leds_init();
D8Led_init();
D8Led_segment(RL._8_4_);
portG_conf(6,EINT);
portG_eint_trig(6,FALLING);
portG_conf_pup(6,ENABLE);
portG_conf(7,EINT);
portG_eint_trig(7,FALLING);
portG_conf_pup(7,ENABLE);
tmr_set_prescaler(TIMER0,0xff);
tmr_set_divider(TIMER0,D1_8);
tmr_set_count(TIMER0,0xf424,0x7a12);
tmr_update(TIMER0);
tmr_set_mode(TIMER0,RELOAD);
tmr_stop(TIMER0);
if (RL._0_8_ != 0) {
tmr_start(TIMER0);
}
_DAT_0c7fff18 = (undefined4)irq_ISR;
ic_init();
ic_conf_irq(ENABLE,NOVEC);
ic_conf_fiq(DISABLE);
ic_conf_line(INT_TIMER0,IRQ);
ic_conf_line(INT_EINT4567,IRQ);
ic_enable(INT_TIMER0);
ic_enable(INT_EINT4567);
Delay(0);
return 0;
}
|
int setup(void) {
leds_init();
D8Led_init();
D8Led_segment(RL.position);
portG_conf(6, EINT);
portG_eint_trig(6, FALLING);
portG_conf_pup(6, ENABLE);
portG_conf(7, EINT);
portG_eint_trig(7, FALLING);
portG_conf_pup(7, ENABLE);
tmr_set_prescaler(TIMER0, 255);
tmr_set_divider(TIMER0, D1_8);
tmr_set_count(TIMER0, 62500, 31250);
tmr_update(TIMER0);
tmr_set_mode(TIMER0, RELOAD);
tmr_stop(TIMER0);
if (RL.moving)
tmr_start(TIMER0);
(*(unsigned *)(0xc7fff00 +0x18)) = (unsigned) irq_ISR;
# 158 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/serfati5/EC/refs/heads/master/P2_2/main.c"
ic_init();
ic_conf_irq(ENABLE, NOVEC);
ic_conf_fiq(DISABLE);
ic_conf_line(INT_TIMER0, IRQ);
ic_conf_line(INT_EINT4567, IRQ);
ic_enable(INT_TIMER0);
ic_enable(INT_EINT4567);
Delay(0);
return 0;
}
|
void test_mm_maskz_mul_epu32(void)
{
_mm_maskz_mul_epu32();
return;
}
|
__m128i test_mm_maskz_mul_epu32 (__mmask8 __M, __m128i __X, __m128i __Y) {
return _mm_maskz_mul_epu32(__M, __X, __Y);
}
|
int xlr_phy_write(undefined8 param_1,int param_2,uint param_3,undefined4 param_4)
{
long lVar1;
int iVar2;
long lVar3;
long lVar4;
lVar3 = msecs_to_jiffies(100);
lVar3 = lVar3 + jiffies;
xlr_nae_wreg(param_1,R_MII_MGMT_ADDRESS,param_2 << 8 | param_3);
xlr_nae_wreg(param_1,R_MII_MGMT_WRITE_DATA,param_4);
do {
lVar1 = jiffies;
lVar4 = xlr_nae_rdreg(param_1,R_MII_MGMT_INDICATORS);
if (lVar4 == 0) {
return 0;
}
iVar2 = time_after(lVar1,lVar3);
} while (iVar2 == 0);
pr_info("Phy device write err: device busy");
return -EBUSY;
}
|
int xlr_phy_write(u32 *base_addr, int phy_addr, int regnum, u16 val)
{
unsigned long timeout, stoptime, checktime;
int timedout;
/* 100ms timeout*/
timeout = msecs_to_jiffies(100);
stoptime = jiffies + timeout;
timedout = 0;
xlr_nae_wreg(base_addr, R_MII_MGMT_ADDRESS, (phy_addr << 8) | regnum);
/* Write the data which starts the write cycle */
xlr_nae_wreg(base_addr, R_MII_MGMT_WRITE_DATA, (u32)val);
/* poll for the read cycle to complete */
while (!timedout) {
checktime = jiffies;
if (xlr_nae_rdreg(base_addr, R_MII_MGMT_INDICATORS) == 0)
break;
timedout = time_after(checktime, stoptime);
}
if (timedout) {
pr_info("Phy device write err: device busy");
return -EBUSY;
}
return 0;
}
|
int tolower(int __c)
{
int iVar1;
undefined4 extraout_var;
iVar1 = isalpha(__c);
if (CONCAT44(extraout_var,iVar1) != 0) {
__c = __c | 0x20;
}
return __c;
}
|
inline int tolower(int ch) {
if(isalpha(ch)) {
return ch | 0x20;
} else {
return ch;
}
}
|
undefined8 main(uint param_1,long param_2)
{
long in_FS_OFFSET;
char *local_38;
undefined8 local_30;
char *local_28;
undefined *local_20;
undefined8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = "/sbin/ifconfig";
local_30 = *(undefined8 *)(param_2 + 8);
local_28 = "create";
local_20 = &DAT_001000b1;
local_18 = 0;
printf("Executing %s - %u\n",local_30,(ulong)param_1);
execvp(local_38,&local_38);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
|
int main(int argc, char *argv[])
{
char *cmd[5];
cmd[0] = "/sbin/ifconfig";
cmd[1] = argv[1];
cmd[2] = "create";
cmd[3] = "up";
cmd[4] = NULL;
printf("Executing %s - %u\n",cmd[1], argc);
execvp(cmd[0],cmd);
return 0;
}
|
void div_weo(void)
{
__builtin_divweo();
return;
}
|
int
div_weo (int a, int b)
{
return __builtin_divweo (a, b);
}
|
void f32_trunc(float param_1)
{
truncf(param_1);
return;
}
|
extern inline __attribute__((always_inline)) f32 f32_trunc(f32 a) { return truncf(a); }
|
ulong qp_file_read(long *param_1,void *param_2,ulong param_3,undefined8 param_4)
{
long lVar1;
int iVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
ulong __n;
if ((param_1 == (long *)0x0) && (iVar2 = qp_fd_is_inited(0x18), iVar2 == 0)) {
return 0xffffffff;
}
iVar2 = qp_file_is_directIO(param_1);
uVar5 = param_3;
if (iVar2 == 0) {
param_1 = param_1 + 3;
lVar4 = qp_fd_is_aio(param_1);
if (lVar4 != 0) {
uVar5 = qp_fd_aio_read(param_1,param_2,param_3,param_4);
return uVar5;
}
uVar5 = qp_fd_read(param_1,param_2,param_3);
return uVar5;
}
while( true ) {
lVar4 = *param_1;
lVar1 = param_1[1];
__n = lVar4 - lVar1;
if (uVar5 <= __n) {
memcpy(param_2,(void *)(param_1[2] + lVar1),uVar5);
param_1[1] = param_1[1] + uVar5;
return uVar5 & 0xffffffff;
}
memcpy(param_2,(void *)(param_1[2] + lVar1),__n);
uVar5 = uVar5 + (lVar1 - lVar4);
uVar3 = qp_file_track(param_1);
if ((int)uVar3 < 1) break;
param_2 = (void *)((long)param_2 + __n);
if (uVar5 == 0) {
LAB_001000c5:
return param_3 & 0xffffffff;
}
}
if (uVar5 != 0) {
return uVar3;
}
goto LAB_001000c5;
}
|
ssize_t
qp_file_read(qp_file_t file, void* data, size_t len, size_t file_offset)
{
if (!file && !qp_fd_is_inited(&file->file)) {
return -1;
}
if (!qp_file_is_directIO(file)) {
return qp_fd_is_aio(&file->file) ?
qp_fd_aio_read(&file->file, data, len, file_offset) :
qp_fd_read(&file->file, data, len);
} else {
size_t done = len;
size_t rest = 0;
ssize_t ret = 0;
do {
rest = file->rdbuf_offset - file->rdbuf_offsetlast;
if (len > rest) {
memcpy(data, file->rdbuf + file->rdbuf_offsetlast, rest);
data += rest;
len -= rest;
if (1 > (ret = qp_file_track(file))) {
break;
}
} else {
memcpy(data, file->rdbuf + file->rdbuf_offsetlast, len);
file->rdbuf_offsetlast += len;
return len;
}
} while(len);
if (len) {
return ret;
}
return done;
}
}
|
void MatrixMult44pv(undefined8 param_1)
{
undefined4 uVar1;
long lVar2;
long in_FS_OFFSET;
undefined4 local_54;
undefined local_50 [4];
undefined local_4c [4];
undefined4 local_48;
undefined local_44 [4];
undefined local_40 [4];
undefined local_3c [4];
undefined local_38 [4];
undefined local_34 [4];
long local_30;
lVar2 = 0;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
do {
uVar1 = RandomMatrix44(param_1);
*(undefined4 *)((long)&local_54 + lVar2) = uVar1;
uVar1 = RandomMatrix44(param_1);
*(undefined4 *)((long)&local_48 + lVar2) = uVar1;
lVar2 = lVar2 + 4;
} while (lVar2 != 0xc);
M_MatMult44pv(local_3c,&local_54,&local_48);
M_MatMult44pv(local_38,local_50,local_44);
M_MatMult44pv(local_34,local_4c,local_40);
UseMatrix(local_3c);
UseMatrix(local_38);
UseMatrix(local_34);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void
MatrixMult44pv(void *ti)
{
M_Matrix44 A[3], B[3], AB[3];
int i;
for (i = 0; i < 3; i++) { A[i] = RandomMatrix44(ti); B[i] = RandomMatrix44(ti); }
for (i = 0; i < 3; i++) { M_MatMult44pv(&AB[i], &A[i], &B[i]); }
for (i = 0; i < 3; i++) { UseMatrix(&AB[i]); }
}
|
void pr_fail_args_errno(undefined4 *param_1,undefined8 param_2,undefined4 param_3)
{
pr_msg_fail(9,*param_1,param_2,param_3);
return;
}
|
void pr_fail_args_errno(const stress_args_t *args, const char *msg, int err)
{
pr_msg_fail((0x00000000000008ULL) | (0x00000000000001ULL), args->name, msg, err);
}
|
void command_playlist_update_write(long param_1,undefined8 param_2,undefined8 param_3)
{
if (param_1 == 0) {
param_1 = playlist_get_cached();
}
if (param_1 != 0) {
playlist_update(param_1,param_2,param_3);
playlist_write_file(param_1);
}
return;
}
|
void command_playlist_update_write(
playlist_t *plist,
size_t idx,
const struct playlist_entry *entry)
{
playlist_t *playlist = plist ? plist : playlist_get_cached();
if (!playlist)
return;
playlist_update(
playlist,
idx,
entry);
playlist_write_file(playlist);
}
|
void map_new_subnode(long *param_1,char param_2)
{
long lVar1;
undefined4 uVar2;
lVar1 = *param_1;
uVar2 = map_new_node();
*(undefined4 *)(lVar1 + (long)param_2 * 4) = uVar2;
return;
}
|
void map_new_subnode(_map *node, char key) {
node->sub_nodes[key] = map_new_node();
return;
}
|
bool lteq_it_cag_long_array(long param_1,long param_2)
{
return param_1 <= param_2;
}
|
int lteq_it_cag_long_array(const it_cag_long_array it1, const it_cag_long_array it2) { return ( (it1) <= (it2) ); }
|
undefined8 alias_completion_alias_value_cb(void)
{
undefined8 in_R8;
long in_FS_OFFSET;
int local_34;
char *local_30;
char *local_28;
long local_20;
undefined4 *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = (char *)(**weechat_alias_plugin)(in_R8,&DAT_00100156);
if (local_28 != (char *)0x0) {
local_20 = (*weechat_alias_plugin[1])(local_28,&DAT_0010015b,0,7,0,&local_34);
if (local_20 != 0) {
if (local_34 < 1) {
local_30 = strdup(local_28);
}
else {
local_30 = strdup(*(char **)(local_20 + (long)local_34 * 8 + -8));
}
if (local_30 != (char *)0x0) {
local_18 = (undefined4 *)alias_search(local_30);
if (local_18 != (undefined4 *)0x0) {
(*weechat_alias_plugin[3])(in_R8,*local_18,0,"beginning");
}
free(local_30);
}
(*weechat_alias_plugin[2])(local_20);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
|
int
alias_completion_alias_value_cb (const void *pointer, void *data,
const char *completion_item,
struct t_gui_buffer *buffer,
struct t_gui_completion *completion)
{
const char *args;
char **argv, *alias_name;
int argc;
struct t_alias *ptr_alias;
(void) pointer;
(void) data;
(void) completion_item;
(void) buffer;
args = (weechat_alias_plugin->completion_get_string)(completion, "args");
if (args)
{
argv = (weechat_alias_plugin->string_split)(args, " ", NULL, (1 << 0) | (1 << 1) | (1 << 2), 0, &argc)
;
if (argv)
{
if (argc > 0)
alias_name = strdup (argv[argc - 1]);
else
alias_name = strdup (args);
if (alias_name)
{
ptr_alias = alias_search (alias_name);
if (ptr_alias)
{
(weechat_alias_plugin->completion_list_add)(completion, ptr_alias->command, 0, "beginning")
;
}
free (alias_name);
}
(weechat_alias_plugin->string_free_split)(argv);
}
}
return 0;
}
|
undefined4 main(void)
{
time_t tVar1;
long in_FS_OFFSET;
char local_15;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
tVar1 = time((time_t *)0x0);
srand((uint)tVar1);
do {
local_14 = -1;
while (local_14 == -1) {
sleepTime();
emptyConsole();
displayChoices();
local_14 = getUserChoice();
}
gameMangerMain(local_14);
printf("Do you want to continue? (Y/N) ");
scanf("\n%c",&local_15);
} while ((local_15 == 'Y') || (local_15 == 'y'));
printf("\nPress the Enter or Return key to exit\n");
getchar();
getchar();
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return EXIT_SUCCESS;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int main(int argc, char *argv[]) {
int userChoice;
char loopBreak;
srand(time(0));
while (1)
{
userChoice = -1;
while (userChoice == -1) {
sleepTime();
emptyConsole();
displayChoices();
userChoice = getUserChoice();
}
gameMangerMain(userChoice);
printf("Do you want to continue? (Y/N) ");
scanf("\n%c", &loopBreak);
if (!(loopBreak == 'Y' || loopBreak == 'y')) {
break;
}
}
printf("\nPress the Enter or Return key to exit\n");
getchar();
getchar();
return EXIT_SUCCESS;
}
|
undefined8 a_exec(long *param_1)
{
long lVar1;
long *plVar2;
if ((param_1 != (long *)0x0) && (*param_1 != 0)) {
plVar2 = param_1 + 1;
do {
spawn();
lVar1 = *plVar2;
plVar2 = plVar2 + 1;
} while (lVar1 != 0);
return 0;
}
return 0;
}
|
int
a_exec(char * opt[]) {
int i;
if(opt)
for(i=0; opt[i]; i++)
if(opt[i]) spawn(opt[i]);
return 0;
}
|
void addVariableMap(long *param_1,undefined4 *param_2,undefined8 param_3)
{
int iVar1;
undefined8 *puVar2;
assert(*param_2);
iVar1 = crsx_allocate(param_1[1] & 0xffffffff,4);
puVar2 = (undefined8 *)(long)iVar1;
puVar2[2] = *param_1;
puVar2[1] = param_2;
*puVar2 = param_3;
*param_1 = (long)puVar2;
return;
}
|
void addVariableMap(VariableMap map, Variable key, Variable value)
{
assert(key->name);
VariableMapLink link = (VariableMapLink) crsx_allocate((Context)map->context,sizeof(struct _VariableMapLink));
link->link = map->link;
link->key = key;
link->value = value;
map->link = link;
}
|
double maxabs(ulong *param_1,int param_2)
{
int local_14;
double local_10;
local_10 = (double)(*param_1 & DAT_001000a0);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (local_10 < (double)(param_1[local_14] & DAT_001000a0)) {
local_10 = (double)(param_1[local_14] & DAT_001000a0);
}
}
return local_10;
}
|
double maxabs(double *ar, int len) {
double MaxEntry;
int i;
MaxEntry = fabs(ar[0]);
for (i = 0; i < len; i++) {
if (fabs(ar[i]) > MaxEntry) {
MaxEntry = fabs(ar[i]);
}
}
return MaxEntry;
}
|
void _Locale_monetary_create(undefined8 param_1,undefined8 param_2,undefined8 param_3)
{
_Locale_create(param_1,param_3);
return;
}
|
struct _Locale_monetary* _Locale_monetary_create(const char *name,
struct _Locale_name_hint* hint, int *__err_code)
{ return (struct _Locale_monetary*)_Locale_create(name, __err_code); }
|
long dynamicArrCharGetStr(int *param_1)
{
long lVar1;
ulong local_28;
long local_20;
ulong *local_18;
local_20 = 0;
lVar1 = mem_alloc(*param_1 + 1);
for (local_18 = *(ulong **)(param_1 + 2); local_18 != (ulong *)0x0;
local_18 = (ulong *)local_18[2]) {
for (local_28 = 0; local_28 < *local_18; local_28 = local_28 + 1) {
*(undefined *)(local_20 + lVar1) = *(undefined *)(local_28 + local_18[1]);
local_20 = local_20 + 1;
}
}
*(undefined *)(lVar1 + *param_1) = 0;
return lVar1;
}
|
char* dynamicArrCharGetStr(DynamicArrChar* darr) {
int64 i;
int64 j = 0;
char* str = (char*)mem_alloc((sizeof(char)*darr->used) + 1);
DynamicArrCharNode* node;
for (node = darr->first; node != NULL; node = node->next) {
for (i = 0; i < node->i; i++) {
str[j] = node->arr[i];
j++;
}
}
str[darr->used] = '\0';
return str;
}
|
undefined8 list_airport_at(uint *param_1,uint param_2)
{
undefined8 uVar1;
uint local_34;
undefined4 local_1c;
undefined8 local_18;
local_1c = LIST_HEAD;
local_34 = param_2;
if ((int)param_2 < 0) {
local_1c = LIST_TAIL;
local_34 = ~param_2;
}
if (local_34 < *param_1) {
uVar1 = list_airport_iterator_new(param_1,local_1c);
local_18 = list_iterator_next_airport(uVar1);
while( true ) {
if (local_34 == 0) break;
local_18 = list_iterator_next_airport(uVar1);
local_34 = local_34 - 1;
}
list_airport_iterator_destroy(uVar1);
}
else {
local_18 = 0;
}
return local_18;
}
|
airport *
list_airport_at(airports *self, int index) {
list_direction_t direction = LIST_HEAD;
if(index < 0) {
direction = LIST_TAIL;
index = ~index;
}
if((unsigned)index < self->length) {
airport_iterator *it = list_airport_iterator_new(self, direction);
airport *node = list_iterator_next_airport(it);
while(index--)
node = list_iterator_next_airport(it);
list_airport_iterator_destroy(it);
return node;
}
return NULL;
}
|
void * pcap_lib_version(void)
{
char *__s;
size_t sVar1;
void *pvVar2;
pvVar2 = pcap_lib_version_string;
if (pcap_lib_version_string == (void *)0x0) {
__s = (char *)PacketGetVersion();
sVar1 = strlen(__s);
sVar1 = (long)(int)sVar1 + 2;
pvVar2 = malloc(sVar1);
if (pvVar2 != (void *)0x0) {
pcap_snprintf(pvVar2,sVar1,pcap_version_string_packet_dll_fmt,__s);
pcap_lib_version_string = pvVar2;
return pvVar2;
}
}
return pvVar2;
}
|
const char *
pcap_lib_version(void)
{
char *packet_version_string;
size_t full_pcap_version_string_len;
char *full_pcap_version_string;
if (pcap_lib_version_string == NULL) {
/*
* Generate the version string. Report the packet.dll
* version.
*
* The -2 is for the %s in the format string, which will
* be replaced by packet_version_string.
*/
packet_version_string = PacketGetVersion();
full_pcap_version_string_len =
(sizeof pcap_version_string_packet_dll_fmt - 2) +
strlen(packet_version_string);
full_pcap_version_string = malloc(full_pcap_version_string_len);
if (full_pcap_version_string == NULL)
return (NULL);
pcap_snprintf(full_pcap_version_string,
full_pcap_version_string_len,
pcap_version_string_packet_dll_fmt,
packet_version_string);
pcap_lib_version_string = full_pcap_version_string;
}
return (pcap_lib_version_string);
}
|
undefined8 compile_file(undefined8 param_1,undefined8 param_2,undefined8 param_3,uint param_4)
{
undefined8 uVar1;
undefined8 *puVar2;
undefined8 uVar3;
if ((param_4 & 2) == 0) {
uVar1 = BijouVM_new(0);
puVar2 = (undefined8 *)BijouBlock_new(0);
*puVar2 = param_3;
puVar2[1] = &_LC0;
compile_function(param_1,uVar1,puVar2);
uVar3 = to_proto(uVar1,puVar2);
if (param_4 == 0) {
bijou_dump(uVar1,uVar3,writer,param_2);
}
}
else {
_debug_ = 1;
uVar1 = BijouVM_new(0);
puVar2 = (undefined8 *)BijouBlock_new(0);
*puVar2 = param_3;
puVar2[1] = &_LC0;
compile_function(param_1,uVar1,puVar2);
uVar3 = to_proto(uVar1,puVar2);
}
BijouBlock_destroy(puVar2);
BijouVM_destroy(uVar1);
Proto_destroy(uVar3);
return 0;
}
|
int compile_file(FILE* in, FILE* out, char* filename, unsigned int options)
{
if (options & (1 << 1)) {
_debug_ = 1;
}
BijouVM* vm = BijouVM_new(0);
BijouBlock* block = BijouBlock_new(0);
block->filename = filename;
block->funcname = "main";
compile_function(in, vm, block);
Proto *p = to_proto(vm, block);
if (! options & (1 << 0))
bijou_dump(vm, p, writer, out);
BijouBlock_destroy(block);
BijouVM_destroy(vm);
Proto_destroy(p);
return 0;
}
|
void cpu_ldd_at_hl(void)
{
cpu_advance_time(8);
cpu._8_4_ = rbyte((cpu._0_4_ & 0xff) << 8 | (uint)cpu[4]);
return;
}
|
void cpu_ldd_at_hl() {
cpu_advance_time((2) << 2);
cpu.d = (rbyte((((cpu.h)&0xFF) << 8) | ((cpu.l)&0xFF)));;
}
|
uint cksm(undefined8 param_1,long param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
int iVar5;
iVar5 = *(short *)(param_2 + 0x12) + 0xe;
uVar1 = 0;
if (0xe < iVar5) {
uVar1 = 0;
uVar4 = *(uint *)(param_2 + 0xc);
uVar2 = 0xe;
while( true ) {
uVar1 = uVar1 + (uVar4 & 0xffff);
uVar3 = uVar2 + 2;
if (iVar5 <= (int)uVar3) break;
uVar4 = uVar2 + 5;
if (-1 < (int)uVar3) {
uVar4 = uVar3;
}
uVar4 = *(uint *)(param_2 + (long)((int)uVar4 >> 2) * 4);
uVar2 = uVar3;
if ((uVar3 & 3) == 0) {
uVar4 = (int)uVar4 >> 0x10;
}
}
for (; (int)uVar1 >> 0x10 != 0; uVar1 = (uVar1 & 0xffff) + ((int)uVar1 >> 0x10)) {
}
}
return ~uVar1;
}
|
uint16_t cksm(int length, uint32_t buf[]) {
uint32_t sum = 0;
int ind = 14;
int max = ind + (buf[4] >> 16);
while (ind < max) {
int i = ind / 4;
int shift = !(ind % 4);
uint32_t val = buf[i];
if (shift) val >>= 16;
val &= 0xffff;
sum += val;
ind += 2;
}
while (sum >> 16)
sum = (sum & 0xffff) + (sum >> 16);
sum = ~sum;
return ((uint16_t)sum);
}
|
code * x2130z(code *param_1,undefined8 param_2,undefined8 param_3,int param_4,int param_5)
{
code *pcVar1;
uint uVar2;
undefined4 extraout_EAX;
code *pcVar3;
pcVar3 = x2130;
pcVar1 = x2130;
if ((param_1 != (code *)0x0) && (pcVar3 = param_1, pcVar1 = param_1, x2130 != (code *)0x0)) {
uVar2 = (*param_1)(0);
m((void *)((ulong)x2130 & 0xffffffff),uVar2,(char *)(ulong)uVar2,param_4,param_5);
pcVar3 = (code *)Y(extraout_EAX);
pcVar1 = x2130;
}
x2130 = pcVar1;
return pcVar3;
}
|
f x2130z( f y){y =y?! x2130?x2130= y:Y( m(*( w)& x2130,(( g)y) (0)) ):x2130;return y; }
|
bool list_empty(long *param_1)
{
return *param_1 == 0;
}
|
int list_empty(List *list) {
return list->head == NULL;
}
|
bool executable(long *param_1,undefined8 param_2,int param_3)
{
int iVar1;
char *__file;
long lVar2;
undefined8 uVar3;
undefined4 extraout_var;
long in_FS_OFFSET;
bool bVar4;
uint local_24;
__dev_t local_20;
local_20 = *(__dev_t *)(in_FS_OFFSET + 0x28);
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
__file = (char *)short2str(param_2);
}
else {
uVar3 = Strspl();
__file = (char *)short2str(uVar3);
xfree(uVar3);
}
iVar1 = stat(__file,(stat *)&local_24);
if (iVar1 != -1) {
if (param_3 != 0) {
lVar2 = S_ISDIR(local_24);
bVar4 = true;
if (lVar2 != 0) goto LAB_00100076;
}
lVar2 = S_ISREG(local_24);
if ((lVar2 != 0) && ((local_24 & (S_IXOTH | S_IXGRP | S_IXUSR)) != 0)) {
iVar1 = access(__file,X_OK);
bVar4 = CONCAT44(extraout_var,iVar1) == 0;
goto LAB_00100076;
}
}
bVar4 = false;
LAB_00100076:
if (local_20 != *(__dev_t *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return bVar4;
}
|
int
executable(const Char *dir, const Char *name, int dir_ok)
{
struct stat stbuf;
char *strname;
if (dir && *dir) {
Char *path;
path = Strspl(dir, name);
strname = short2str(path);
xfree(path);
}
else
strname = short2str(name);
return (stat(strname, &stbuf) != -1 &&
((dir_ok && S_ISDIR(stbuf.st_mode)) ||
(S_ISREG(stbuf.st_mode) &&
/* save time by not calling access() in the hopeless case */
(stbuf.st_mode & (S_IXOTH | S_IXGRP | S_IXUSR)) &&
access(strname, X_OK) == 0
)));
}
|
undefined8 SendSBYE(int *param_1)
{
uint uVar1;
long in_FS_OFFSET;
char acStack_228 [520];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = sprintf(acStack_228,"%s\r\n",*(undefined8 *)(CommandString + OUT * 8));
write(*param_1,acStack_228,(ulong)uVar1);
DestroyChatList(param_1[5]);
DestroyChatList(param_1[4]);
DestroyChatList(param_1[3]);
DestroyChatList(param_1[2]);
DestroyChatList(param_1[1]);
m_input_remove(param_1);
close(*param_1);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int SendSBYE(MSN_Conn *conn)
{
char commandLine[513 +1];
int length;
length = sprintf(commandLine, "%s\r\n", CommandString[OUT]);
write(conn->fd, commandLine, length);
DestroyChatList(conn->chatUsers);
DestroyChatList(conn->flUsers);
DestroyChatList(conn->alUsers);
DestroyChatList(conn->blUsers);
DestroyChatList(conn->rlUsers);
m_input_remove(conn);
close(conn->fd);
return 0;
}
|
void init_summary(long *param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
bool bVar4;
bVar4 = DataFieldCount != 0;
param_1[6] = 0;
*(undefined (*) [16])(param_1 + 2) = (undefined [16])0x0;
*(undefined (*) [16])(param_1 + 4) = (undefined [16])0x0;
if (bVar4) {
lVar1 = param_1[1];
lVar2 = *param_1;
uVar3 = 0;
do {
*(undefined8 *)(*(long *)(lVar1 + Minimum * 8) + uVar3 * 8) = DBL_MAX;
*(undefined8 *)(*(long *)(lVar1 + Maximum * 8) + uVar3 * 8) = DBL_MIN;
*(undefined8 *)(*(long *)(lVar1 + Total * 8) + uVar3 * 8) = 0;
*(undefined8 *)(*(long *)(lVar1 + Average * 8) + uVar3 * 8) = 0;
*(undefined8 *)(lVar2 + uVar3 * 8) = 0;
uVar3 = uVar3 + 1;
} while (uVar3 < DataFieldCount);
}
return;
}
|
void init_summary(Summary *s) {
DataField i;
s->elapsed = s->moving = s->calories = s->ascent = s->descent = 0;
for (i = 0; i < DataFieldCount; i++) {
s->point[Minimum].data[i] = DBL_MAX;
s->point[Maximum].data[i] = DBL_MIN;
s->point[Total].data[i] = 0;
s->point[Average].data[i] = 0;
s->unset[i] = 0;
}
}
|
void HJoinMonitor(void)
{
long in_FS_OFFSET;
undefined local_14 [4];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
HJoinThread(monThread,local_14);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void HJoinMonitor(void)
{
int status;
HJoinThread(monThread,&status);
}
|
void SetDefaultBenchmarkState(undefined4 *param_1)
{
param_1[0xc] = MB;
strcpy((char *)(ulong)(uint)param_1[0xb],"MB");
*param_1 = 1;
param_1[1] = 1;
param_1[2] = 1;
param_1[3] = 1;
param_1[10] = WRITE_BUFFER;
*(undefined8 *)(param_1 + 8) = 0;
strcpy((char *)(ulong)(uint)param_1[6],"");
return;
}
|
void SetDefaultBenchmarkState( BenchmarkTestState *state )
{
state->unit = MB;
strcpy( state->unit_str, "MB" );
state->initial_size = 1;
state->increment_factor = 1;
state->num_tests = 1;
state->timing_samples = 1;
state->test_operation = WRITE_BUFFER;
state->flags = NULL;
strcpy( state->flags_str, "" );
state->output_filename[255];
}
|
undefined8 array_set_first(long param_1,undefined8 param_2)
{
undefined8 uVar1;
if (param_1 != 0) {
uVar1 = array_set_index(param_1,param_2,0);
return uVar1;
}
return 0xffffffff;
}
|
int array_set_first(const ArrayList *list, const void *data){
if(((list)) == (NULL)){return (((-1)));};
return array_set_index(list, data, 0);
}
|
int string_tuple_length(int param_1)
{
int iVar1;
iVar1 = param_1 + 10;
if (-1 < param_1 + 7) {
iVar1 = param_1 + 7;
}
return iVar1 >> 2;
}
|
irk_int
string_tuple_length (irk_int n)
{
irk_int word_size = sizeof (object);
irk_int len_size = sizeof (int32_t);
irk_int nwords = (((n + len_size)+(word_size)-1)/(word_size));
return nwords;
}
|
void altera_i2c_reset(undefined8 param_1)
{
altera_i2c_disable(param_1);
altera_i2c_enable(param_1);
return;
}
|
void altera_i2c_reset(struct altera_i2c_dev *dev)
{
altera_i2c_disable(dev);
altera_i2c_enable(dev);
}
|
undefined8 LL_Find(long param_1,code *param_2,long param_3)
{
int iVar1;
undefined8 uVar2;
long lVar3;
if (((param_1 != 0) && (param_2 != (code *)0x0)) && (param_3 != 0)) {
do {
uVar2 = LL_Get(param_1);
iVar1 = (*param_2)(uVar2,param_3);
if (iVar1 == 0) {
return uVar2;
}
lVar3 = LL_Next(param_1);
} while (lVar3 == 0);
}
return 0;
}
|
void *
LL_Find(LinkedList *list, int (*compare)(void *, void *), void *value)
{
if (!list)
return NULL;
if (!compare)
return NULL;
if (!value)
return NULL;
do {
void *data = LL_Get(list);
if (0 == compare(data, value))
return data;
} while (LL_Next(list) == 0);
return NULL;
}
|
void mid_pci_get_power_state(void)
{
intel_mid_pci_get_power_state();
return;
}
|
pci_power_t mid_pci_get_power_state(struct pci_dev *pdev)
{
return intel_mid_pci_get_power_state(pdev);
}
|
int FillSageInfo(undefined *param_1,void *param_2,int param_3,undefined param_4)
{
undefined uVar1;
if (param_3 < 0xc) {
return 0;
}
memcpy(param_2,&_LC0,4);
*(undefined *)((long)param_2 + 4) = 4;
*(undefined *)((long)param_2 + 5) = param_4;
*(char *)((long)param_2 + 6) = (char)*(undefined4 *)(param_1 + 0x20);
*(char *)((long)param_2 + 7) = (char)*(undefined4 *)(param_1 + 0x1c);
uVar1 = 0;
if (*(long *)(param_1 + 0x10) == 0) {
uVar1 = param_1[0x18];
}
*(undefined *)((long)param_2 + 8) = uVar1;
uVar1 = 1;
if (*(long *)(param_1 + 0x10) == 0) {
uVar1 = *param_1;
}
*(undefined *)((long)param_2 + 9) = uVar1;
*(char *)((long)param_2 + 10) = (char)*(undefined4 *)(param_1 + 4);
*(char *)((long)param_2 + 0xb) = (char)*(undefined4 *)(param_1 + 0xc);
if (*(int *)(param_1 + 4) == 0x1b) {
FillSageDesc((long)param_2 + 0xc,param_3 + -0xc,0x40,param_1 + 8,1);
}
return param_3;
}
|
int FillSageInfo( PS_BUILDER* pBuilder, unsigned char* ptr, int bytes, unsigned char CtrlBits )
{
int used_bytes = 0;
if ( bytes < 12 ) return 0;
memcpy( ptr, "SAGE", 4 );
ptr += 4;
*ptr++ = 4;
*ptr++ = CtrlBits;
*ptr++ = pBuilder->total_video_num;
*ptr++ = pBuilder->total_audio_num;
*ptr++ = pBuilder->remapping_stream ? 0 : pBuilder->main_video_index;
*ptr++ = pBuilder->remapping_stream ? 1 : pBuilder->main_audio_index;
*ptr++ = pBuilder->main_video_stream_type;
*ptr++ = pBuilder->main_audio_stream_type;
used_bytes = 4+8;
if ( pBuilder->main_video_stream_type == 0x1b )
{
FillSageDesc( ptr, bytes-used_bytes, 0x40, (char*)&pBuilder->h264_frame_rate, 1 );
}
return bytes;
}
|
void riu_push(void)
{
long lVar1;
lVar1 = new_riu();
*(long **)(lVar1 + 8) = stack;
if (stack != (long *)0x0) {
*stack = lVar1;
}
stack = (long *)lVar1;
return;
}
|
void
riu_push(off_t offset, size_t extent, void *vp)
{
riu *riup = new_riu(offset, extent, vp);
riup->next = stack;
if(stack != NULL)
stack->prev = riup;
stack = riup;
}
|
int system(char *__command)
{
__pid_t __pid;
undefined4 extraout_var;
long in_FS_OFFSET;
int local_4c;
char *local_48;
undefined *local_40;
char *local_38;
undefined8 local_30;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = "/system/bin/sh";
local_40 = &_LC1;
local_30 = 0;
local_38 = __command;
__pid = fork();
if (CONCAT44(extraout_var,__pid) == 0) {
execve(local_48,&local_48,(char **)(ulong)__environ);
local_48 = "/bin/sh";
execve("/bin/sh",&local_48,(char **)(ulong)__environ);
/* WARNING: Subroutine does not return */
_exit(-1);
}
waitpid(__pid,&local_4c,0);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_4c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int system(char* cmd)
{
char* argv[4];
argv[0] = "/system/bin/sh";
argv[1] = "-c";
argv[2] = cmd;
argv[3] = NULL;
pid_t pid = fork();
if (pid == 0)
{
execve(argv[0], argv, __environ);
argv[0] = "/bin/sh";
execve(argv[0], argv, __environ);
_exit(-1);
}
int status;
waitpid(pid, &status, 0);
return status;
}
|
int f(int param_1)
{
return param_1 + -1;
}
|
int f(struct S s) {
return --s.S;
}
|
undefined8 getChunk(int param_1)
{
undefined8 *puVar1;
undefined8 uVar2;
if (param_1 < 4) {
param_1 = 4;
}
puVar1 = (undefined8 *)malloc((ulong)(param_1 + 0xc));
if (puVar1 == (undefined8 *)0x0) {
fprintf((FILE *)(ulong)stderr,"malloc failed!\n");
uVar2 = 0x30;
}
else {
puVar1[1] = chunkList;
uVar2 = *puVar1;
chunkList = puVar1;
}
return uVar2;
}
|
char *getChunk(int size) {
CHUNK *chunk;
if (size < 4)
size = 4;
chunk = malloc(size + sizeof(CHUNK) - 4);
if (chunk == NULL) {
fprintf(stderr, "malloc failed!\n");
return (char *) '0';
}
if (chunk == NULL)
return NULL;
chunk->next = chunkList;
chunkList = chunk;
return chunk->data;
}
|
undefined4 scdb_cas(void)
{
return SCDB_ERROR;
}
|
scdb_status scdb_cas(scdb_index* index, const char* key, size_t key_length,
const char* current_value, size_t current_value_length,
const char* new_value, size_t new_value_length) {
return SCDB_ERROR;
}
|
void enter_cap_mode(int param_1,char **param_2)
{
long lVar1;
long lVar2;
long in_FS_OFFSET;
undefined local_2c [4];
char *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cap_rights_init(local_2c,CAP_FSTAT,CAP_MMAP_R);
if (param_1 == 0) {
param_2 = &local_28;
param_1 = 1;
local_28 = strdup((char *)(ulong)nm_info);
if (local_28 == (char *)0x0) {
err(EXIT_FAILURE,"strdup");
}
}
lVar1 = fileargs_init(param_1,param_2,O_RDONLY,0,local_2c,FA_OPEN);
if (lVar1 == 0) {
err(EXIT_FAILURE,"failed to initialize fileargs");
}
caph_cache_catpages();
lVar2 = caph_limit_stdio();
if (lVar2 < 0) {
err(EXIT_FAILURE,"failed to limit stdio rights");
}
lVar2 = caph_enter_casper();
if (lVar2 < 0) {
err(EXIT_FAILURE,"failed to enter capability mode");
}
nm_opts = lVar1;
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void
enter_cap_mode(int argc, char **argv)
{
cap_rights_t rights;
fileargs_t *fa;
char *defaultfn;
cap_rights_init(&rights, CAP_FSTAT, CAP_MMAP_R);
if (argc == 0) {
defaultfn = strdup(nm_info.def_filename);
if (defaultfn == NULL)
err(EXIT_FAILURE, "strdup");
argc = 1;
argv = &defaultfn;
}
fa = fileargs_init(argc, argv, O_RDONLY, 0, &rights, FA_OPEN);
if (fa == NULL)
err(EXIT_FAILURE, "failed to initialize fileargs");
caph_cache_catpages();
if (caph_limit_stdio() < 0)
err(EXIT_FAILURE, "failed to limit stdio rights");
if (caph_enter_casper() < 0)
err(EXIT_FAILURE, "failed to enter capability mode");
nm_opts.fileargs = fa;
}
|
undefined8 main(void)
{
long lVar1;
int iVar2;
int iVar3;
long in_FS_OFFSET;
undefined8 uVar4;
undefined auVar5 [16];
undefined auVar6 [16];
int local_28;
uint local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
scanf("%d",&local_28);
if (local_28 != 0) {
iVar3 = 0;
do {
scanf("%d",&local_24);
auVar5 = (undefined [16])0x0;
if (1 < (int)local_24) {
iVar2 = 1;
do {
lVar1 = (long)iVar2;
iVar2 = iVar2 + 2;
auVar5._0_4_ = auVar5._0_4_ + (float)(int)(1 / lVar1);
} while (iVar2 < (int)local_24);
}
uVar4 = auVar5._0_8_;
if ((local_24 & 1) != 0) {
auVar6._4_12_ = auVar5._4_12_;
auVar6._0_4_ = auVar5._0_4_ + (float)(int)(1 / (long)(int)local_24);
uVar4 = auVar6._0_8_;
}
iVar3 = iVar3 + 1;
printf("%.1f\n",uVar4);
} while (local_28 != iVar3);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int main()
{
int m, n, i, j;
float sum;
scanf("%d", &m);
for (i = 0; i != m; ++i)
{
sum = 0;
scanf("%d", &n);
for (j = 1; j < n; j += 2)
{
sum += 1 / j - 1 / (j + 1);
}
if (n % 2)
sum += 1 / n;
printf("%.1f\n", sum);
}
return 0;
}
|
void lex_comment(undefined4 *param_1)
{
char local_d;
local_d = next(param_1);
while ((local_d != '\0' && (local_d != '\n'))) {
local_d = next(param_1);
}
param_1[1] = param_1[1] + 1;
ignore(param_1);
*param_1 = lex_any;
token(0x100,0);
return;
}
|
TOKEN lex_comment(LEXER *l)
{
int n = 0;
char c;
for (c = next(l); c != '\0' && c != '\n'; c = next(l))
n++;
l->line++;
ignore(l);
l->f = lex_any;
return token(256, NULL);
}
|
undefined8 BTIC4B_ImgRGBe_CheckValidSp(uint param_1)
{
undefined8 uVar1;
if (((param_1 >> 0x18 & 0x1f) == 0) || ((param_1 >> 0x18 & 0x1f) == 0x1f)) {
uVar1 = 0;
}
else if (((param_1 & 0xff | (int)param_1 >> 8 & 0xffU | (int)param_1 >> 0x10 & 0xffU) & 0x80) == 0
) {
uVar1 = 0;
}
else {
uVar1 = 1;
}
return uVar1;
}
|
int BTIC4B_ImgRGBe_CheckValidSp(u32 px)
{
int e, r, g, b, c;
e=(px>>24)&255; b=(px>>16)&255;
g=(px>> 8)&255; r=(px )&255;
if(!(e&31) || (e&31)==31)
return(0);
c=r|g|b;
if(!(c&0x80))
return(0);
return(1);
}
|
void clear(void)
{
undefined auVar1 [16];
undefined auVar2 [16];
undefined auVar3 [16];
undefined auVar4 [16];
undefined auVar5 [16];
undefined auVar6 [16];
long lVar7;
undefined (*pauVar8) [16];
undefined4 uVar9;
pauVar8 = linect;
lVar7 = CL;
if (CL != 0) {
curc = 0;
curr = 0;
realc = 0xffffffff;
realr = 0xffffffff;
auVar1._8_4_ = 0xffffffff;
auVar1._0_8_ = 0xffffffffffffffff;
auVar1._12_4_ = 0xffffffff;
*linect = auVar1;
uVar9 = CO;
auVar2._8_4_ = 0xffffffff;
auVar2._0_8_ = 0xffffffffffffffff;
auVar2._12_4_ = 0xffffffff;
pauVar8[1] = auVar2;
auVar3._8_4_ = 0xffffffff;
auVar3._0_8_ = 0xffffffffffffffff;
auVar3._12_4_ = 0xffffffff;
pauVar8[2] = auVar3;
auVar4._8_4_ = 0xffffffff;
auVar4._0_8_ = 0xffffffffffffffff;
auVar4._12_4_ = 0xffffffff;
pauVar8[3] = auVar4;
auVar5._8_4_ = 0xffffffff;
auVar5._0_8_ = 0xffffffffffffffff;
auVar5._12_4_ = 0xffffffff;
pauVar8[4] = auVar5;
auVar6._8_4_ = 0xffffffff;
auVar6._0_8_ = 0xffffffffffffffff;
auVar6._12_4_ = 0xffffffff;
pauVar8[5] = auVar6;
buffnum = 0xffffffff;
tputs(lVar7,uVar9,&addbuf);
return;
}
writel(&_LC0);
return;
}
|
void
clear ()
{
register int i;
int addbuf();
if (CL == 0) {
writel ("\n\n");
return;
}
curr = curc = 0;
realr = realc = -1;
for (i = 0; i < 24; i++)
linect[i] = -1;
buffnum = -1;
tputs (CL,CO,addbuf);
}
|
undefined8 * initStoryStack(void)
{
undefined8 *puVar1;
undefined8 uVar2;
puVar1 = (undefined8 *)malloc(0x18);
puVar1[2] = 0;
puVar1[1] = 0;
*puVar1 = 0;
uVar2 = initStoryEvent("In victory or death, your quest to defeat THE WRAITH ends in this place.")
;
pushStoryStack(puVar1,uVar2);
uVar2 = initStoryEvent("Beneath the ruins of a small tower you find a maze of dark passageways.");
pushStoryStack(puVar1,uVar2);
return puVar1;
}
|
StoryStack* initStoryStack(char* bossName) {
StoryStack* stack = malloc(sizeof(StoryStack));
stack->head = NULL;
stack->firstPrinted = NULL;
stack->lastPrinted = NULL;
StoryEvent* storyOpen = initStoryEvent("In victory or death, your quest to defeat THE WRAITH ends in this place.");
pushStoryStack(stack, storyOpen);
storyOpen = initStoryEvent("Beneath the ruins of a small tower you find a maze of dark passageways.");
pushStoryStack(stack, storyOpen);
return stack;
}
|
void clenshaw(long param_1,int *param_2,uint *param_3)
{
double dVar1;
int iVar2;
double *pdVar3;
long lVar4;
long lVar5;
double *pdVar6;
double *pdVar7;
ulong uVar8;
long lVar9;
uint uVar10;
double dVar11;
double dVar12;
double dVar13;
double dVar14;
uVar10 = *param_3;
dVar14 = 0.0;
if ((uVar10 & 1) != 0) {
uVar8 = (ulong)uVar10;
uVar10 = uVar10 - 1;
dVar14 = *(double *)(*(long *)(param_3 + 2) + uVar8 * 8);
}
if (0 < *param_2) {
pdVar3 = *(double **)(param_3 + 2);
lVar4 = *(long *)(param_2 + 2);
lVar5 = *(long *)(param_1 + 8);
lVar9 = 0;
dVar1 = *pdVar3;
do {
iVar2 = *(int *)(lVar4 + lVar9 * 4);
dVar13 = (double)(iVar2 * 2);
dVar11 = 0.0;
pdVar6 = pdVar3 + (int)uVar10;
dVar12 = dVar14;
if (0 < (int)uVar10) {
do {
pdVar7 = pdVar6 + -2;
dVar11 = (dVar13 * dVar12 + *pdVar6) - dVar11;
dVar12 = (dVar13 * dVar11 + pdVar6[-1]) - dVar12;
pdVar6 = pdVar7;
} while (pdVar3 + (long)(int)uVar10 + (ulong)(uVar10 - 1 >> 1) * -2 + -2 != pdVar7);
}
*(int *)(lVar5 + lVar9 * 4) = (int)((dVar12 * (double)iVar2 + dVar1) - dVar11);
lVar9 = lVar9 + 1;
} while ((int)lVar9 < *param_2);
}
return;
}
|
void
clenshaw(struct points *y, struct points *x, struct coefficients *c)
{
int i, k;
unsigned d;
double b, x2;
double be, bo;
d = c->degree;
if (d & 1) {
b = c->val[d];
d--;
} else {
b = 0;
}
for (i = 0; i < x->len; i++) {
x2 = 2 * x->val[i];
be = 0;
bo = b;
for (k = d; k > 0; k -= 2) {
be = c->val[k] + x2 * bo - be;
bo = c->val[k-1] + x2 * be - bo;
}
y->val[i] = c->val[0] + x->val[i] * bo - be;
}
}
|
undefined4 f2fs_init_extent_tree(undefined8 param_1)
{
undefined4 uVar1;
int *piVar2;
uVar1 = __f2fs_init_extent_tree();
piVar2 = (int *)F2FS_I(param_1);
if (*piVar2 != 0) {
return uVar1;
}
set_inode_flag(param_1,FI_NO_EXTENT);
return uVar1;
}
|
bool f2fs_init_extent_tree(struct inode *inode, struct f2fs_extent *i_ext)
{
bool ret = __f2fs_init_extent_tree(inode, i_ext);
if (!F2FS_I(inode)->extent_tree)
set_inode_flag(inode, FI_NO_EXTENT);
return ret;
}
|
void ADCHardwareOversampleConfigure(int param_1,int param_2)
{
int local_20;
int local_c;
local_c = 0;
for (local_20 = param_2 >> 1; local_20 != 0; local_20 = local_20 >> 1) {
local_c = local_c + 1;
}
*(int *)(long)(param_1 + 0x30) = local_c;
return;
}
|
void
ADCHardwareOversampleConfigure(uint32_t ui32Base, uint32_t ui32Factor)
{
uint32_t ui32Value;
;
;
for(ui32Value = 0, ui32Factor >>= 1; ui32Factor;
ui32Value++, ui32Factor >>= 1)
{
}
(*((volatile uint32_t *)(ui32Base + 0x00000030))) = ui32Value;
}
|
FILE * chimeraxBegin(undefined8 param_1)
{
FILE *__stream;
long in_FS_OFFSET;
undefined8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__stream = (FILE *)mustOpen(param_1,&_LC0);
fputs((char *)(ulong)chimeraxHead,__stream);
local_18 = mustOpen(chimeraxPythonFile,&_LC1);
copyOpenFile(local_18,__stream);
carefulClose(&local_18);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return __stream;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
FILE *chimeraxBegin(char *outName)
{
FILE *xfh = mustOpen(outName, "w");
fputs(chimeraxHead, xfh);
FILE *pxf = mustOpen(chimeraxPythonFile, "r");
copyOpenFile(pxf, xfh);
carefulClose(&pxf);
return xfh;
}
|
undefined8 ngx_http_lua_fake_delayed_load_function(void)
{
return 0;
}
|
int
ngx_http_lua_fake_delayed_load_function(lua_State * L)
{
return 0;
}
|
void mpi_div(undefined8 param_1,undefined8 param_2,undefined8 param_3)
{
mpi_divqr(param_1,0,param_2,param_3);
return;
}
|
void
mpi_div(mpi *rop, mpi *num, mpi *den)
{
mpi_divqr(rop, NULL, num, den);
}
|
ulong fuse_file_aio_read(undefined8 *param_1,undefined8 param_2,undefined8 param_3,long param_4)
{
undefined8 uVar1;
uint uVar2;
long *plVar3;
long lVar4;
long lVar5;
ulong uVar6;
uVar1 = **(undefined8 **)*param_1;
plVar3 = (long *)get_fuse_conn(uVar1);
if (*plVar3 == 0) {
lVar4 = iov_length(param_2,param_3);
lVar5 = i_size_read(uVar1);
if (lVar4 + param_4 <= lVar5) goto LAB_001000a1;
}
uVar2 = fuse_update_attributes(uVar1,0,*param_1,0);
if (uVar2 != 0) {
return (ulong)uVar2;
}
LAB_001000a1:
uVar6 = generic_file_aio_read(param_1,param_2,param_3,param_4);
return uVar6;
}
|
ssize_t fuse_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos)
{
struct inode *inode = iocb->ki_filp->f_mapping->host;
struct fuse_conn *fc = get_fuse_conn(inode);
/*
* In auto invalidate mode, always update attributes on read.
* Otherwise, only update if we attempt to read past EOF (to ensure
* i_size is up to date).
*/
if (fc->auto_inval_data ||
(pos + iov_length(iov, nr_segs) > i_size_read(inode))) {
int err;
err = fuse_update_attributes(inode, NULL, iocb->ki_filp, NULL);
if (err)
return err;
}
return generic_file_aio_read(iocb, iov, nr_segs, pos);
}
|
undefined4 ng_udbp_rcvmsg(undefined4 param_1,undefined4 param_2)
{
undefined4 uVar1;
NG_NODE_PRIVATE();
NGI_GET_MSG(param_2,0);
uVar1 = EINVAL;
if (iRam0000000000000008 == 0x82) {
if (_DAT_00000010 == 0x80) {
if (_DAT_0000000c == 4) {
uVar1 = 0;
DPRINTF("flags = 0x%08x\n",*_DAT_00000000);
}
}
else if (_DAT_00000010 == 0x81) {
NG_MKRESPONSE(0,0,8,M_NOWAIT);
uVar1 = ENOMEM;
}
}
NG_RESPOND_MSG(uVar1,param_1,param_2,0);
NG_FREE_MSG(0);
return uVar1;
}
|
int
ng_udbp_rcvmsg(node_p node, item_p item, hook_p lasthook)
{
struct udbp_softc *sc = NG_NODE_PRIVATE(node);
struct ng_mesg *resp = NULL;
int error = 0;
struct ng_mesg *msg;
NGI_GET_MSG(item, msg);
/* Deal with message according to cookie and command */
switch (msg->header.typecookie) {
case NGM_UDBP_COOKIE:
switch (msg->header.cmd) {
case NGM_UDBP_GET_STATUS:
{
struct ngudbpstat *stats;
NG_MKRESPONSE(resp, msg, sizeof(*stats), M_NOWAIT);
if (!resp) {
error = ENOMEM;
break;
}
stats = (struct ngudbpstat *)resp->data;
mtx_lock(&sc->sc_mtx);
stats->packets_in = sc->sc_packets_in;
stats->packets_out = sc->sc_packets_out;
mtx_unlock(&sc->sc_mtx);
break;
}
case NGM_UDBP_SET_FLAG:
if (msg->header.arglen != sizeof(uint32_t)) {
error = EINVAL;
break;
}
DPRINTF("flags = 0x%08x\n",
*((uint32_t *)msg->data));
break;
default:
error = EINVAL; /* unknown command */
break;
}
break;
default:
error = EINVAL; /* unknown cookie type */
break;
}
/* Take care of synchronous response, if any */
NG_RESPOND_MSG(error, node, item, resp);
NG_FREE_MSG(msg);
return (error);
}
|
int randix_next(uint *param_1)
{
uint uVar1;
uint uVar2;
uVar1 = *param_1;
do {
if ((param_1[2] & *param_1) == 0) {
uVar2 = *param_1 * 2;
}
else {
uVar2 = param_1[3] ^ *param_1 * 2;
}
*param_1 = param_1[4] & uVar2;
} while ((int)param_1[1] <= (int)*param_1);
return uVar1 - 1;
}
|
int
randix_next(struct _randix *p) {
int rv = p->ss-1;
do {
p->ss = ((((p->ss) & p->tbit) ? (((p->ss) << 1) ^ (p->xorm)) : ((p->ss) << 1)) & p->mask);
} while(p->ss >= p->length);
return rv;
}
|
void Tree_Is_Red(undefined8 param_1,undefined4 param_2)
{
Tree_Get_Color(param_1,param_2);
return;
}
|
bool Tree_Is_Red(struct Tree* m, var node) {
return Tree_Get_Color(m, node);
}
|
long get_min_len(void)
{
long param_7;
long param_8;
long param_9;
long param_10;
long param_11;
return param_10 + param_11 + param_9 + param_8 + param_7 * 2;
}
|
size_t get_min_len (struct pwd_policy policy)
{
return policy.ascii_digit.min
+ policy.ascii_alpha_lower.min
+ policy.ascii_alpha_upper.min
+ policy.ascii_special.min
+ policy.utf8_alpha_lower.min
+ policy.utf8_alpha_lower.min;
}
|
undefined8 main(void)
{
int iVar1;
thds = omp_get_max_threads();
if (thds == 1) {
printf("should be run this program on multi threads.\n");
/* WARNING: Subroutine does not return */
exit(0);
}
omp_set_dynamic(0);
iVar1 = omp_get_thread_num();
x = iVar1 + x;
printf("err_threadprivate 007 : FAILED, can not compile this program.\n");
return 1;
}
|
main ()
{
thds = omp_get_max_threads ();
if (thds == 1) {
printf ("should be run this program on multi threads.\n");
exit (0);
}
omp_set_dynamic (0);
#pragma omp parallel reduction(+:x)
{
int id = omp_get_thread_num ();
x += id;
}
printf ("err_threadprivate 007 : FAILED, can not compile this program.\n");
return 1;
}
|
undefined8 CalculateIndexSize(char param_1)
{
undefined8 uVar1;
if ((param_1 < '0') || ('9' < param_1)) {
if ((param_1 < 'A') || ('z' < param_1)) {
printf("Error");
uVar1 = 0xffffffff;
}
else {
uVar1 = 0x1a;
}
}
else {
uVar1 = 10;
}
return uVar1;
}
|
int CalculateIndexSize (char index_char)
{
if (index_char >= '0' && index_char <= '9') {
return 10;
}
else if (index_char >= 'A' && index_char <= 'z') {
return 26;
}
else {
printf("Error");
return -1;
}
}
|
undefined8 ctoken_stream_load(undefined8 param_1,char *param_2)
{
long lVar1;
undefined8 uVar2;
long *plVar3;
long in_FS_OFFSET;
undefined8 local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = param_1;
lVar1 = ctoken_reader_create(ctoken_stream_text_getch,&local_38);
assert(lVar1);
uVar2 = ctoken_new_endf();
assert(uVar2);
*param_2 = '\0';
do {
plVar3 = (long *)ctoken_reader_read(lVar1);
if (plVar3 == (long *)0x0) {
strncpy(param_2,(char *)(ulong)*(uint *)(lVar1 + 8),100);
ctoken_reader_release(lVar1);
ctoken_stream_free(uVar2);
uVar2 = 0;
LAB_001000ae:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if (*plVar3 == CTokenENDF) {
ctoken_reader_release(lVar1);
goto LAB_001000ae;
}
ctoken_list_add_tail(plVar3,uVar2);
} while( true );
}
|
CTOKEN *ctoken_stream_load(const char *text, char *error)
{
CTokenReader *reader;
CTOKEN *root;
char *string;
int retval;
string = (char*)text;
reader = ctoken_reader_create(ctoken_stream_text_getch, &string);
assert(reader);
root = ctoken_new_endf();
assert(root);
for (retval = 0, *error = 0; ; ) {
CTOKEN *token;
token = ctoken_reader_read(reader);
if (token == NULL) {
if (error) strncpy(error, reader->error, 100);
retval = -1;
break;
}
if (token->type == CTokenENDF) {
break;
}
ctoken_list_add_tail(token, root);
}
ctoken_reader_release(reader);
if (retval != 0) {
ctoken_stream_free(root);
return NULL;
}
return root;
}
|
undefined8 ldp_panel_remove(void)
{
return 0;
}
|
int ldp_panel_remove(struct platform_device *pdev)
{
return 0;
}
|
int git_reader_for_index(long **param_1,long param_2,long param_3)
{
undefined4 uVar1;
int iVar2;
long *plVar3;
assert(param_2 != 0 && param_1 != (long **)0x0);
plVar3 = (long *)git__calloc(1,0x18);
GIT_ERROR_CHECK_ALLOC(plVar3);
uVar1 = index_reader_read;
plVar3[1] = param_2;
*(undefined4 *)(plVar3 + 2) = uVar1;
if (param_3 == 0) {
iVar2 = git_repository_index__weakptr(plVar3,param_2);
if (iVar2 < 0) {
git__free(plVar3);
return iVar2;
}
}
else {
*plVar3 = param_3;
}
*param_1 = plVar3;
return 0;
}
|
int git_reader_for_index(
git_reader **out,
git_repository *repo,
git_index *index)
{
index_reader *reader;
int error;
assert(out && repo);
reader = git__calloc(1, sizeof(index_reader));
GIT_ERROR_CHECK_ALLOC(reader);
reader->reader.read = index_reader_read;
reader->repo = repo;
if (index) {
reader->index = index;
} else if ((error = git_repository_index__weakptr(&reader->index, repo)) < 0) {
git__free(reader);
return error;
}
*out = (git_reader *)reader;
return 0;
}
|
void handler(void)
{
int iVar1;
long in_FS_OFFSET;
sigaltstack local_28;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
printf("Caught SIGQUIT\n");
iVar1 = sigaltstack((sigaltstack *)0x0,&local_28);
if (iVar1 == -1) {
perror("Unexpected error while attempting to setup test pre-conditions");
/* WARNING: Subroutine does not return */
exit(-1);
}
if ((local_28.ss_sp == (void *)current._0_8_) && (local_28._8_8_ == current._8_8_)) {
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
printf("Test FAILED\n");
/* WARNING: Subroutine does not return */
exit(-1);
}
|
void handler(int signo __attribute__((unused)))
{
stack_t oss;
printf("Caught SIGQUIT\n");
if (sigaltstack(NULL, &oss) == -1) {
perror("Unexpected error while attempting to setup test "
"pre-conditions");
exit(-1);
}
if (oss.ss_sp != current.ss_sp || oss.ss_size != current.ss_size) {
printf("Test FAILED\n");
exit(-1);
}
}
|
void mode_tree_up(long *param_1,int param_2)
{
long lVar1;
if (*param_1 == 0) {
if (param_2 != 0) {
lVar1 = param_1[1];
*param_1 = lVar1 + -1;
if (param_1[2] <= lVar1) {
param_1[3] = lVar1 - param_1[2];
return;
}
}
}
else {
lVar1 = *param_1 + -1;
*param_1 = lVar1;
if (lVar1 < param_1[3]) {
param_1[3] = param_1[3] + -1;
}
}
return;
}
|
void
mode_tree_up(struct mode_tree_data *mtd, int wrap)
{
if (mtd->current == 0) {
if (wrap) {
mtd->current = mtd->line_size - 1;
if (mtd->line_size >= mtd->height)
mtd->offset = mtd->line_size - mtd->height;
}
} else {
mtd->current--;
if (mtd->current < mtd->offset)
mtd->offset--;
}
}
|
undefined8 stubFuncIV(void)
{
return 0xffffffff;
}
|
int32_t stubFuncIV(void) {
return -1;
}
|
ulong coloridx(char *param_1)
{
int iVar1;
ulong uVar2;
char *__s2;
ulong uVar3;
long in_FS_OFFSET;
char *apcStack_68 [5];
char *local_40;
undefined *puStack_38;
char *local_30;
undefined8 local_28;
long local_20;
__s2 = "black";
uVar2 = 0;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = 0;
apcStack_68[1] = &_LC1;
apcStack_68[2] = "green";
local_30 = "white";
apcStack_68[3] = "yellow";
apcStack_68[4] = &_LC4;
local_40 = "magenta";
puStack_38 = &_LC6;
do {
uVar3 = uVar2 & 0xffffffff;
iVar1 = strcmp(param_1,__s2);
if (iVar1 == 0) goto LAB_001000c4;
uVar2 = uVar2 + 1;
__s2 = apcStack_68[uVar2];
} while (__s2 != (char *)0x0);
uVar3 = 0xffffffff;
LAB_001000c4:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int
coloridx(const char *color)
{
const char *tab[] = {
"black",
"red",
"green",
"yellow",
"blue",
"magenta",
"cyan",
"white",
NULL
};
int i;
for (i = 0; tab[i] != NULL; ++i)
if (!strcmp(color, tab[i]))
return i;
return -1;
}
|
void TK_DisableTkPolarity(int param_1)
{
*TK = *TK & ~(param_1 << ((byte)TK_POLCTL_POLEN0_Pos & 0x1f));
return;
}
|
void TK_DisableTkPolarity(uint32_t u32Mask)
{
TK->POLCTL &= ~(u32Mask << TK_POLCTL_POLEN0_Pos);
}
|
int xt_hashlimit_len_to_chunks(int param_1)
{
return (param_1 >> ((byte)XT_HASHLIMIT_BYTE_SHIFT & 0x1f)) + 1;
}
|
u32 xt_hashlimit_len_to_chunks(u32 len)
{
return (len >> XT_HASHLIMIT_BYTE_SHIFT) + 1;
}
|
ulong uvc_v4l2_streamon(undefined8 param_1,undefined8 param_2,int param_3)
{
undefined8 uVar1;
undefined4 *puVar2;
ulong uVar3;
uVar1 = video_devdata();
puVar2 = (undefined4 *)video_get_drvdata(uVar1);
if (puVar2[1] == param_3) {
uVar3 = uvcg_video_enable(puVar2 + 1,1);
if (-1 < (int)uVar3) {
uvc_function_setup_continue(puVar2);
*puVar2 = UVC_STATE_STREAMING;
return 0;
}
}
else {
uVar3 = (ulong)(uint)-EINVAL;
}
return uVar3;
}
|
int
uvc_v4l2_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
{
struct video_device *vdev = video_devdata(file);
struct uvc_device *uvc = video_get_drvdata(vdev);
struct uvc_video *video = &uvc->video;
int ret;
if (type != video->queue.queue.type)
return -EINVAL;
/* Enable UVC video. */
ret = uvcg_video_enable(video, 1);
if (ret < 0)
return ret;
/*
* Complete the alternate setting selection setup phase now that
* userspace is ready to provide video frames.
*/
uvc_function_setup_continue(uvc);
uvc->state = UVC_STATE_STREAMING;
return 0;
}
|
void yahoo_f01_57(uint param_1,undefined4 param_2)
{
yahoo_M1Common(param_1 ^ 0x6d86030f,param_2);
return;
}
|
int yahoo_f01_57(int Salt, int Parameter)
{
unsigned b = Salt ^ 0x6D86030F;
return yahoo_M1Common(b, Parameter);
}
|
undefined4 * createstrobj(undefined8 param_1,long param_2,undefined4 param_3,undefined4 param_4)
{
undefined8 uVar1;
undefined4 *puVar2;
long lVar3;
uVar1 = sizelstring(param_2);
uVar1 = luaC_newobj(param_1,param_3,uVar1);
puVar2 = (undefined4 *)gco2ts(uVar1);
*puVar2 = param_4;
*(undefined8 *)(puVar2 + 2) = 0;
lVar3 = getstr(puVar2);
*(undefined *)(lVar3 + param_2) = 0;
return puVar2;
}
|
TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) {
TString *ts;
GCObject *o;
size_t totalsize; /* total size of TString object */
totalsize = sizelstring(l);
o = luaC_newobj(L, tag, totalsize);
ts = gco2ts(o);
ts->hash = h;
ts->extra = 0;
getstr(ts)[l] = '\0'; /* ending 0 */
return ts;
}
|
undefined4 processCtrlRdr(undefined8 param_1,undefined8 param_2,undefined8 param_3,int *param_4)
{
int iVar1;
long lVar2;
undefined4 uVar3;
long in_FS_OFFSET;
undefined4 local_18;
undefined4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (*param_4 == 0) {
lVar2 = saHpiControlGet(param_1,param_2,param_4[1],&local_14,&local_18);
if (SA_OK == lVar2) {
iVar1 = isValidCtrlMode(local_14);
if (iVar1 == 0) {
m_print("Invalid Control Mode [0x%x]!",local_14);
uVar3 = 1;
}
else {
iVar1 = isValidCtrlType(local_18);
uVar3 = 0;
if (iVar1 == 0) {
m_print("Invalid Contrl Type [0x%x]!",local_18);
uVar3 = 1;
}
}
}
else {
e_print(saHpiControlGet,SA_OK,lVar2);
uVar3 = 1;
}
}
else {
uVar3 = 3;
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int processCtrlRdr(SaHpiSessionIdT sessionId,
SaHpiResourceIdT resourceId,
SaHpiRdrT * rdr, SaHpiCtrlRecT * ctrlRec)
{
SaErrorT status;
int retval = 3;
SaHpiCtrlStateT ctrlState;
SaHpiCtrlModeT ctrlMode;
SaHpiCtrlNumT ctrlNum = ctrlRec->Num;
if (!ctrlRec->WriteOnly) {
status = saHpiControlGet(sessionId, resourceId, ctrlNum,
&ctrlMode, &ctrlState);
if (status != SA_OK) {
retval = 1;
e_print(saHpiControlGet, SA_OK, status);
} else {
if (!isValidCtrlMode(ctrlMode)) {
retval = 1;
m_print("Invalid Control Mode [0x%x]!",
ctrlMode);
} else if (!isValidCtrlType(ctrlState.Type)) {
retval = 1;
m_print("Invalid Contrl Type [0x%x]!",
ctrlState.Type);
} else {
retval = 0;
}
}
}
return retval;
}
|
long FindFE(long param_1,int param_2,int param_3,long param_4)
{
long lVar1;
int iVar2;
int local_28;
int local_24;
if (((param_1 != 0) &&
(local_28 = param_3 + -1, *(long *)(param_1 + (long)param_2 * 8) <= param_4)) &&
(local_24 = param_2, param_4 <= *(long *)(param_1 + (long)local_28 * 8))) {
do {
iVar2 = (local_28 + local_24) / 2;
lVar1 = *(long *)(param_1 + (long)iVar2 * 8);
if (param_4 == lVar1) {
return param_1 + (long)iVar2 * 8;
}
if (lVar1 < param_4) {
local_24 = iVar2 + 1;
}
else {
local_28 = iVar2 + -1;
}
} while (local_24 <= local_28);
}
return 0;
}
|
FLEntry *FindFE(FLEntry *fptr, int lo, int hi, LM_Id key)
{
int cen;
LM_Id cmp;
if (fptr==NULL)
return NULL;
hi--;
if ((key < fptr[lo].ndx) || (key > fptr[hi].ndx))
return NULL;
do {
cen = (lo + hi) / 2;
cmp = fptr[cen].ndx;
if (key == cmp)
return fptr+cen;
if (key > cmp)
lo = cen+1;
else
hi = cen-1;
} while (lo <= hi);
return NULL;
}
|
void init_ait_mode_pages(undefined8 param_1)
{
add_mode_disconnect_reconnect();
add_mode_control(param_1);
add_mode_data_compression(param_1);
add_mode_device_configuration(param_1);
add_mode_medium_partition(param_1);
add_mode_information_exception(param_1);
add_mode_ait_device_configuration(param_1);
return;
}
|
void init_ait_mode_pages(struct lu_phy_attr *lu)
{
add_mode_disconnect_reconnect(lu);
add_mode_control(lu);
add_mode_data_compression(lu);
add_mode_device_configuration(lu);
add_mode_medium_partition(lu);
add_mode_information_exception(lu);
add_mode_ait_device_configuration(lu);
}
|
undefined8 generate_mixed(undefined8 param_1,undefined8 param_2,undefined8 param_3)
{
undefined8 uVar1;
undefined8 uVar2;
long lVar3;
undefined auVar4 [16];
auVar4 = strip_symbol(param_2,param_3);
uVar2 = auVar4._8_8_;
uVar1 = auVar4._0_8_;
auVar4 = scan_symbol(uVar1,uVar2);
lVar3 = auVar4._0_8_;
write_leading(param_1,param_2,param_3,uVar1,uVar2);
if (auVar4._8_8_ != lVar3) {
write_lower(param_1,lVar3,auVar4._8_8_);
while( true ) {
auVar4 = scan_symbol(uVar1,uVar2,lVar3);
lVar3 = auVar4._0_8_;
if (lVar3 == auVar4._8_8_) break;
write_cap(param_1,lVar3);
}
}
write_trailing(param_1,param_2,param_3,uVar1,uVar2);
return 1;
}
|
int generate_mixed(FILE *out, String s)
{
String inner = strip_symbol(s);
String word = scan_symbol(inner, inner.p);
write_leading(out, s, inner);
if (((word).end - (word).p)) {
write_lower(out, word);
word = scan_symbol(inner, word.end);
}
while (((word).end - (word).p)) {
write_cap(out, word);
word = scan_symbol(inner, word.end);
}
write_trailing(out, s, inner);
return 1;
}
|
void cpum_cf_offline_cpu(undefined8 param_1)
{
cpum_cf_setup(param_1,PMC_RELEASE);
return;
}
|
int cpum_cf_offline_cpu(unsigned int cpu)
{
return cpum_cf_setup(cpu, PMC_RELEASE);
}
|
void prim_intfromstr(long **param_1,undefined4 *param_2,undefined8 param_3,long *param_4)
{
long lVar1;
undefined4 uVar2;
undefined4 uVar3;
lVar1 = param_4[1];
if (VALUE_STRING != *param_4) {
runtime_error(param_3,"argument of #intfromstr must be a string");
}
uVar3 = int_from_cstr(*(undefined4 *)(**param_1 + lVar1 * 4));
uVar2 = VALUE_INT;
*param_2 = uVar3;
param_2[1] = uVar2;
return;
}
|
void prim_intfromstr(Scheduler *sched, Process *proc,Definition *expr, Value args[]) {
Value sarg = args[0];
if (((sarg).ctl) != VALUE_STRING)
runtime_error(expr,"argument of #intfromstr must be a string");
String str = (sched->string_pool->pool[((sarg).val._int)]);
int val = int_from_cstr(str.str);
Value vval;
(((vval).val._int) = (val));
(((proc->val).ctl)= (VALUE_INT) );
(((proc->val).val._int) = (((vval).val._int)));
}
|
char * mbrevstrpbrk(char *param_1,undefined8 param_2,char *param_3)
{
int iVar1;
long lVar2;
char *local_20;
local_20 = param_3;
if (*param_3 == '\0') {
if (param_3 == param_1) {
return (char *)0x0;
}
iVar1 = step_left(param_1,(int)param_3 - (int)param_1);
local_20 = param_1 + iVar1;
}
while( true ) {
if (TRUE == 0) {
return (char *)0x0;
}
lVar2 = mbstrchr(param_2,local_20);
if (lVar2 != 0) break;
if (local_20 == param_1) {
return (char *)0x0;
}
iVar1 = step_left(param_1,(int)local_20 - (int)param_1);
local_20 = param_1 + iVar1;
}
return local_20;
}
|
char *mbrevstrpbrk(const char *head, const char *accept, const char *pointer)
{
if (*pointer == '\0') {
if (pointer == head)
return NULL;
pointer = head + step_left(head, pointer - head);
}
while (TRUE) {
if (mbstrchr(accept, pointer) != NULL)
return (char *)pointer;
if (pointer == head)
return NULL;
pointer = head + step_left(head, pointer - head);
}
}
|
void _rsbi_d(undefined8 param_1,undefined4 param_2,undefined4 param_3,undefined8 param_4)
{
long lVar1;
undefined4 uVar2;
long lVar3;
undefined8 uVar4;
uVar2 = jit_get_reg(jit_class_fpr);
lVar1 = _rvs;
lVar3 = jit_regno(uVar2);
uVar4 = jit_regno(*(undefined4 *)(lVar3 * 4 + lVar1));
_movi_d(param_1,uVar4,param_4);
lVar1 = _rvs;
lVar3 = jit_regno(uVar2);
uVar4 = jit_regno(*(undefined4 *)(lVar3 * 4 + lVar1));
_FA(param_1,0x3f,param_2,uVar4,param_3,0,0x14,0);
jit_unget_reg(uVar2);
return;
}
|
void _rsbi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0) { jit_int32_t reg = jit_get_reg(jit_class_fpr); _movi_d(_jit,(jit_regno(_rvs[jit_regno(reg)].spec)),i0); _FA(_jit,63,r0,(jit_regno(_rvs[jit_regno(reg)].spec)),r1,0,20,0); jit_unget_reg(reg); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.