instruction
stringlengths 27
1.88k
| output
stringlengths 21
2.78k
|
|---|---|
void iio_dma_buffer_block_done(long *param_1)
{
long lVar1;
long lVar2;
lVar2 = *param_1;
lVar1 = lVar2 + 4;
spin_lock_irqsave(lVar1,0);
_iio_dma_buffer_block_done(param_1);
spin_unlock_irqrestore(lVar1,0);
iio_buffer_block_put_atomic(param_1);
wake_up_interruptible_poll(lVar2,EPOLLIN | EPOLLRDNORM);
return;
}
|
void iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)
{
struct iio_dma_buffer_queue *queue = block->queue;
unsigned long flags;
spin_lock_irqsave(&queue->list_lock, flags);
_iio_dma_buffer_block_done(block);
spin_unlock_irqrestore(&queue->list_lock, flags);
iio_buffer_block_put_atomic(block);
wake_up_interruptible_poll(&queue->buffer.pollq, EPOLLIN | EPOLLRDNORM);
}
|
cfg80211_join_mesh(undefined8 param_1,undefined8 *param_2,undefined8 param_3,undefined8 param_4)
{
undefined8 uVar1;
undefined4 uVar2;
uVar1 = *param_2;
mutex_lock(param_1);
wdev_lock(uVar1);
uVar2 = __cfg80211_join_mesh(param_1,param_2,param_3,param_4);
wdev_unlock(uVar1);
mutex_unlock(param_1);
return uVar2;
}
|
int cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
struct net_device *dev,
struct mesh_setup *setup,
const struct mesh_config *conf)
{
struct wireless_dev *wdev = dev->ieee80211_ptr;
int err;
mutex_lock(&rdev->devlist_mtx);
wdev_lock(wdev);
err = __cfg80211_join_mesh(rdev, dev, setup, conf);
wdev_unlock(wdev);
mutex_unlock(&rdev->devlist_mtx);
return err;
}
|
undefined8 libconfig_yyget_extra(undefined8 *param_1)
{
return *param_1;
}
|
struct scan_context * libconfig_yyget_extra (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
return yyg->yyextra_r;
}
|
undefined8 ports(void)
{
int iVar1;
undefined8 uVar2;
long in_FS_OFFSET;
undefined auStack_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
endport = 0;
porterror = 0;
kissflags = 0;
*(undefined4 *)(poffset + 0x5c) = 0x100;
bseek(fp2,portoffset,SEEK_SET);
PortRec = fp2;
bseek(fp2,portoffset,SEEK_SET);
bputi(portnum,fp2);
LogicalPortNum = portnum;
while ((endport == 0 && (iVar1 = feof((FILE *)(ulong)fp1), iVar1 == 0))) {
GetNextLine(auStack_218);
decode_port_rec(auStack_218);
}
if (porterror == 0) {
if (*(int *)(PortDefined + LogicalPortNum * 4) != 0) {
Consoleprintf("Port %d already defined");
heading = 1;
}
*(undefined4 *)(PortDefined + LogicalPortNum * 4) = 1;
bseek(fp2,portoffset + 0x70,SEEK_SET);
bputi(kissflags,fp2);
portoffset = portoffset + 0x400;
portnum = portnum + 1;
uVar2 = 1;
}
else {
Consoleprintf("Error in port definition");
uVar2 = 0;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
}
|
int ports(int i)
{
char rec[512];
endport=0;
porterror=0;
kissflags=0;
poffset[23]=256;
bseek(fp2,(long) portoffset,SEEK_SET);
PortRec = (struct PORTCONFIG *)fp2;
bseek(fp2,(long) portoffset,SEEK_SET);
bputi(portnum,fp2);
LogicalPortNum = portnum;
while (endport == 0 && !feof(fp1))
{
GetNextLine(rec);
decode_port_rec(rec);
}
if (porterror != 0)
{
Consoleprintf("Error in port definition");
return(0);
}
if (PortDefined[LogicalPortNum])
{
Consoleprintf("Port %d already defined", LogicalPortNum);
heading = 1;
}
PortDefined[LogicalPortNum] = 1;
bseek(fp2,(long) portoffset+112,SEEK_SET);
bputi(kissflags,fp2);
portoffset = portoffset + 1024;
portnum++;
return(1);
}
|
int one(undefined8 param_1,undefined4 param_2)
{
int iVar1;
int iVar2;
iVar1 = two();
iVar2 = two(param_2);
return iVar2 + iVar1;
}
|
int one(int a, int b){
return two(a) + two(b);
}
|
void map_log(undefined4 *param_1,code **param_2,undefined4 param_3)
{
int iVar1;
long lVar2;
void *__ptr;
long in_FS_OFFSET;
long local_58;
long local_50;
undefined8 local_48;
undefined4 local_40;
undefined8 local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
new_modulekey(&local_58);
iVar1 = (**param_2)(&local_58,param_1);
if (iVar1 != 1) {
if ((param_2[1] != (code *)0x0) && (local_58 != 0)) {
local_38 = insert_keymap(local_58,param_3);
}
if ((param_2[3] != (code *)0x0) && (*(long *)(param_1 + 2) != 0)) {
lVar2 = include_uniq(param_1);
if (lVar2 != 0) {
__ptr = (void *)intkeys2str(*param_1,local_38);
local_40 = insert_uniqmap(__ptr,param_3);
free(__ptr);
}
}
if ((param_2[2] != (code *)0x0) && (local_50 != 0)) {
local_48 = insert_keymap(local_50,param_3);
}
if ((param_2[1] != (code *)0x0) && (local_58 != 0)) {
set_datamap(param_1,&local_58,param_2);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void
map_log (GLogItem * logitem, const GParse * parse, GModule module)
{
GKeyData kdata;
char *uniq_key = NULL;
new_modulekey (&kdata);
if (parse->key_data (&kdata, logitem) == 1)
return;
/* each module requires a data key/value */
if (parse->datamap && kdata.data_key)
kdata.data_nkey = insert_keymap (kdata.data_key, module);
/* each module contains a uniq visitor key/value */
if (parse->visitor && logitem->uniq_key && include_uniq (logitem)) {
uniq_key = intkeys2str (logitem->uniq_nkey, kdata.data_nkey);
/* unique key already exists? */
kdata.uniq_nkey = insert_uniqmap (uniq_key, module);
free (uniq_key);
}
/* root keys are optional */
if (parse->rootmap && kdata.root_key)
kdata.root_nkey = insert_keymap (kdata.root_key, module);
/* each module requires a root key/value */
if (parse->datamap && kdata.data_key)
set_datamap (logitem, &kdata, parse);
}
|
undefined8 mote16_KeyLength(void)
{
return 0x200;
}
|
u4 mote16_KeyLength(void) {
return 16*4*8;
}
|
void serial_remove(long param_1)
{
int *piVar1;
int local_14;
piVar1 = *(int **)(param_1 + 8);
dev_dbg(param_1,"serial_release\n");
for (local_14 = 0; local_14 < *piVar1; local_14 = local_14 + 1) {
serial8250_unregister_port(*(undefined4 *)(*(long *)(piVar1 + 2) + (long)local_14 * 4));
}
if (piVar1[1] == 0) {
pcmcia_disable_device(param_1);
}
return;
}
|
void serial_remove(struct pcmcia_device *link)
{
struct serial_info *info = link->priv;
int i;
dev_dbg(&link->dev, "serial_release\n");
/*
* Recheck to see if the device is still configured.
*/
for (i = 0; i < info->ndev; i++)
serial8250_unregister_port(info->line[i]);
if (!info->slave)
pcmcia_disable_device(link);
}
|
void c3lines_init(undefined4 *param_1,undefined4 param_2,undefined8 param_3,undefined4 param_4)
{
long in_FS_OFFSET;
undefined4 local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_34 = identity3D();
c3lines_prepare(param_2,param_3,param_1 + 2,param_1 + 1,param_4,&local_34);
*param_1 = C3_LINES_TYPE;
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void
c3lines_init(
c3geometry_p g,
c3vertex_p vertices,
size_t count,
c3f lineWidth)
{
c3mat4 i = identity3D();
c3lines_prepare(vertices, count, &g->vertice, &g->textures, lineWidth, &i);
g->type.type = C3_LINES_TYPE;
}
|
void usbSetUartStatus_CP2110(undefined8 param_1,undefined param_2)
{
long in_FS_OFFSET;
undefined local_12;
undefined local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_12 = 0x41;
local_11 = param_2;
usbSetReport_CP2110(param_1,&local_12,2);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int
usbSetUartStatus_CP2110 (UsbDevice *device, unsigned char status) {
const unsigned char report[] = {0X41, status};
return usbSetReport_CP2110(device, report, sizeof(report));
}
|
undefined8 main(undefined4 param_1,undefined8 param_2)
{
int iVar1;
undefined4 local_1c [4];
uint local_c;
local_1c[0] = param_1;
glutInit(local_1c,param_2);
Args(local_1c[0],param_2);
local_c = GLUT_SINGLE;
if (doubleBuffer != 0) {
local_c = GLUT_DOUBLE;
}
local_c = GLUT_RGB | local_c;
glutInitDisplayMode(local_c);
glutCreateWindow("ABGR extension");
iVar1 = glutExtensionSupported("GL_EXT_abgr");
if (iVar1 != 0) {
printf("WARNING: client-side OpenGL has no ABGR extension support!\n");
printf(" Drawing only RGBA (and not ABGR) images and textures.\n");
Init();
glutKeyboardFunc(Key);
glutDisplayFunc(Draw);
glutMainLoop();
return 0;
}
printf("Couldn\'t find abgr extension.\n");
/* WARNING: Subroutine does not return */
exit(0);
}
|
int
main(int argc, char **argv)
{
GLenum type;
glutInit(&argc, argv);
Args(argc, argv);
type = GLUT_RGB;
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
glutInitDisplayMode(type);
glutCreateWindow("ABGR extension");
if (!glutExtensionSupported("GL_EXT_abgr")) {
printf("Couldn't find abgr extension.\n");
exit(0);
}
printf("WARNING: client-side OpenGL has no ABGR extension support!\n");
printf(" Drawing only RGBA (and not ABGR) images and textures.\n");
Init();
glutKeyboardFunc(Key);
glutDisplayFunc(Draw);
glutMainLoop();
return 0;
}
|
void Xz_Construct(undefined8 *param_1)
{
param_1[2] = 0;
param_1[1] = 0;
*param_1 = 0;
return;
}
|
void Xz_Construct(CXzStream *p)
{
p->numBlocks = 0;
p->blocks = NULL;
p->flags = 0;
}
|
uint ftdi_232am_baud_base_to_divisor(int param_1,int param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uVar1 = (uint)(CONCAT44(param_2 - (param_2 >> 0x1f) >> 0x1f,param_2 / 2) / (long)param_1);
uVar3 = uVar1 & 7;
if (uVar3 == 7) {
uVar1 = uVar1 + 1;
uVar3 = uVar1 & 7;
}
uVar2 = (int)uVar1 >> 3;
if (uVar3 == 1) {
return uVar2 | 0xc000;
}
if ((uVar1 & 4) != 0) {
return CONCAT22((short)((int)uVar1 >> 0x13),(short)uVar2) | 0x4000;
}
if (uVar3 != 0) {
return uVar2 | 0x8000;
}
if ((short)uVar2 == 1) {
uVar2 = 0;
}
return uVar2;
}
|
unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
{
unsigned short int divisor;
/* divisor shifted 3 bits to the left */
int divisor3 = base / 2 / baud;
if ((divisor3 & 0x7) == 7)
divisor3++; /* round x.7/8 up to x+1 */
divisor = divisor3 >> 3;
divisor3 &= 0x7;
if (divisor3 == 1)
divisor |= 0xc000;
else if (divisor3 >= 4)
divisor |= 0x4000;
else if (divisor3 != 0)
divisor |= 0x8000;
else if (divisor == 1)
divisor = 0; /* special case for maximum baud rate */
return divisor;
}
|
void avldelmax(int *param_1,undefined8 param_2)
{
long in_FS_OFFSET;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
avl_delete(param_1,param_1 + 1,param_2,&local_14,avl_max);
if (local_14 != 0) {
*param_1 = *param_1 + -1;
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int
avldelmax(AVL_TREE tree, void *data)
{ int found;
avl_delete(tree, &tree->root, data, &found, avl_max);
if ( found )
tree->count--;
return found;
}
|
void crc_control_open(undefined8 *param_1,undefined8 param_2)
{
single_open(param_2,crc_control_show,*param_1);
return;
}
|
int crc_control_open(struct inode *inode, struct file *file)
{
struct drm_crtc *crtc = inode->i_private;
return single_open(file, crc_control_show, crtc);
}
|
uint hex_to_int(long param_1,long param_2)
{
long lVar1;
uint uVar2;
long lVar3;
if (param_2 * 2 == 0) {
uVar2 = 0;
}
else {
lVar3 = 0;
uVar2 = 0;
do {
lVar1 = *(long *)(hex_table + *(long *)(param_1 + lVar3 * 8) * 8);
if (lVar1 == 0xff) {
return 0xffffffff;
}
lVar3 = lVar3 + 1;
uVar2 = uVar2 << 4 | (uint)lVar1;
} while (param_2 * 2 != lVar3);
}
if (INT64_MAX < (int)uVar2) {
return 0xffffffff;
}
return uVar2;
}
|
int64_t hex_to_int(const uint8_t *in, size_t bytes) {
const uint8_t *in2 = (const uint8_t *) in;
uint64_t ret = 0;
bytes *= 2;
for (size_t i = 0; i < bytes; i++) {
ret <<= 4;
uint8_t val = hex_table[in2[i]];
if (val == 0xff) {
return -1;
}
ret |= val;
}
if (ret > INT64_MAX) {
return -1;
}
return (int64_t) ret;
}
|
undefined8 hynix_nand_reg_write_op(code **param_1,uint param_2,undefined4 param_3)
{
long lVar1;
undefined8 uVar2;
long in_FS_OFFSET;
undefined4 local_40;
uint local_3c [4];
undefined4 local_2c;
undefined4 local_28;
undefined4 local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = param_3;
local_3c[0] = param_2;
lVar1 = nand_has_exec_op();
if (lVar1 == 0) {
(*param_1[1])(param_1,NAND_CMD_NONE,param_2 | param_2 << 8,0xffffffff);
(**param_1)(param_1,local_40);
uVar2 = 0;
}
else {
local_28 = NAND_OP_ADDR(1,local_3c,0);
local_24 = NAND_OP_8BIT_DATA_OUT(1,&local_40,0);
local_2c = NAND_OPERATION(*(undefined4 *)(param_1 + 2),&local_28);
uVar2 = nand_exec_op(param_1,&local_2c);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int hynix_nand_reg_write_op(struct nand_chip *chip, u8 addr, u8 val)
{
u16 column = ((u16)addr << 8) | addr;
if (nand_has_exec_op(chip)) {
struct nand_op_instr instrs[] = {
NAND_OP_ADDR(1, &addr, 0),
NAND_OP_8BIT_DATA_OUT(1, &val, 0),
};
struct nand_operation op = NAND_OPERATION(chip->cur_cs, instrs);
return nand_exec_op(chip, &op);
}
chip->legacy.cmdfunc(chip, NAND_CMD_NONE, column, -1);
chip->legacy.write_byte(chip, val);
return 0;
}
|
void rcxb_litnode_hook_free(long *param_1)
{
if (param_1 != (long *)0x0) {
if (*param_1 != 0) {
sfree();
}
sfree(param_1);
return;
}
return;
}
|
void rcxb_litnode_hook_free (void *hook)
{
rcxb_lithook_t *ld = (rcxb_lithook_t *)hook;
if (ld) {
if (ld->data) {
sfree (ld->data);
}
sfree (ld);
}
return;
}
|
void talk(void)
{
say("`%Residence of Jack and Maria Kneedlewood",¤t_sprite);
return;
}
|
void talk( void )
{
say("`%Residence of Jack and Maria Kneedlewood", ¤t_sprite);
}
|
void eraseEol(undefined4 *param_1)
{
fd_printf(*param_1,&DAT_00100027);
return;
}
|
void eraseEol(struct current *current)
{
fd_printf(current->fd, "\x1b[0K");
}
|
void userKeyReleaseAll(void)
{
long lVar1;
long lVar2;
lVar2 = *(long *)(mappedPressed + 0x20);
lVar1 = mappedPressed;
while (lVar2 != 0) {
if (*(long *)(lVar1 + 0x18) != 0) {
animStopRot();
}
*(undefined8 *)(lVar1 + 0x10) = 0;
lVar1 = *(long *)(lVar1 + 8);
lVar2 = *(long *)(lVar1 + 0x20);
}
*(long *)lVar1 = lVar1;
*(long *)(lVar1 + 8) = lVar1;
pressedCnt = 0;
return;
}
|
void userKeyReleaseAll() {
struct mappedItem *item=mappedPressed.next;
while (item->code) {
if (item->rot)
animStopRot(item->rot);
item->pressed=0;
item=item->next;
}
item->next=item;
item->prev=item;
pressedCnt=0;
item=0;
}
|
void down(void)
{
scale = scale - DAT_00100028;
return;
}
|
void
down(void)
{
scale -= .0025;
}
|
undefined4 ItemParse_textstyle(undefined8 param_1,undefined4 param_2)
{
int iVar1;
undefined4 uVar2;
iVar1 = PC_Int_Parse(param_2,param_1);
uVar2 = qfalse;
if (iVar1 != 0) {
uVar2 = qtrue;
}
return uVar2;
}
|
qboolean ItemParse_textstyle( itemDef_t *item, int handle )
{
if( !PC_Int_Parse( handle, &item->textStyle ) )
return qfalse;
return qtrue;
}
|
undefined8 opFSUBiw_a32(uint param_1)
{
double *pdVar1;
uint *puVar2;
undefined8 uVar3;
long lVar4;
long lVar5;
if ((CR0 & 0xc) != 0) {
x86_int(7);
return 1;
}
fpucount = fpucount + 1;
cpu_state._52_4_ = cpu_state._52_4_ + 1;
cpu_state._44_4_ = (int)param_1 >> 3 & 7;
cpu_state._40_4_ = (int)param_1 >> 6 & 3;
cpu_state._48_4_ = param_1 & 7;
if (cpu_state._40_4_ == 3) {
if (cpu_state._32_8_ != 0) {
return 1;
}
}
else {
fetch_ea_32_long();
if (cpu_state._32_8_ != 0) {
return 1;
}
}
lVar4 = geteaw();
uVar3 = cpu_state._16_8_;
if (cpu_state._32_8_ != 0) {
return 1;
}
lVar5 = (long)(int)cpu_state._8_4_;
pdVar1 = (double *)(cpu_state._0_8_ + (ulong)(cpu_state._8_4_ & 7) * 8);
*pdVar1 = *pdVar1 - (double)lVar4;
puVar2 = (uint *)(uVar3 + lVar5 * 4);
*puVar2 = *puVar2 & 0xfffffffb;
cpu_state._24_4_ = cpu_state._24_4_ + -8;
return 0;
}
|
int opFSUBiw_a32(uint32_t rmdat32) { uint16_t t; do { if (CR0.l & 0xc) { x86_int(7); return 1; } fpucount++; } while (0); cpu_state.pc++; cpu_state.rm_data.rm_mod_reg.mod=(rmdat32 >> 6) & 3; cpu_state.rm_data.rm_mod_reg.reg=(rmdat32 >> 3) & 7; cpu_state.rm_data.rm_mod_reg.rm = rmdat32 & 7; if (cpu_state.rm_data.rm_mod_reg.mod != 3) { fetch_ea_32_long(rmdat32); } if (cpu_state.abrt) return 1; t = geteaw(); if (cpu_state.abrt) return 1; cpu_state.ST[((cpu_state.TOP+(0))&7)] -= (double)(int16_t)t; cpu_state.tag[cpu_state.TOP] &= ~(1 << 2); cpu_state._cycles -= (8); return 0; }
|
void main(void)
{
l = l + 5;
return;
}
|
main()
{
l += 5LL;
return l;
}
|
undefined8 get_namepart6(char *param_1,long param_2,undefined4 *param_3)
{
int iVar1;
undefined8 uVar2;
char *pcVar3;
char *pcVar4;
size_t sVar5;
uint local_24;
local_24 = 0;
if (param_1 == (char *)0x0) {
uVar2 = 0xffffffff;
}
else {
iVar1 = memcmp(param_1,"http://",7);
if (iVar1 == 0) {
*param_3 = 0x50;
}
else {
iVar1 = memcmp(param_1,"https://",8);
if (iVar1 != 0) {
printf("URL must start with http:// or https:// %s!",param_1);
return 0xffffffff;
}
*param_3 = 0x1bb;
}
pcVar3 = strchr(param_1,0x5b);
if (pcVar3 == (char *)0x0) {
uVar2 = 0xffffffff;
}
else {
pcVar3 = pcVar3 + 1;
pcVar4 = strchr(param_1,0x5d);
if (pcVar4 == (char *)0x0) {
uVar2 = 0xffffffff;
}
else {
pcVar4 = strchr(pcVar4 + 1,0x3a);
for (; (pcVar3[local_24] != ']' && (sVar5 = strlen(pcVar3), local_24 < (uint)sVar5));
local_24 = local_24 + 1) {
*(char *)(param_2 + (ulong)local_24) = pcVar3[local_24];
}
*(undefined *)(param_2 + (ulong)local_24) = 0;
if (pcVar4 != (char *)0x0) {
sscanf(pcVar4 + 1,"%d",param_3);
}
uVar2 = 0;
}
}
}
return uVar2;
}
|
int get_namepart6(char *src, char *host, int *port) {
char *croch = NULL;
char *croch2 = NULL;
char *colon = NULL;
unsigned int pos = 0;
if (!src) { return -1; }
if (!memcmp(src, "http://", 7)) {
*port = 80;
} else if (!memcmp(src, "https://", 8)) {
*port = 443;
} else {
printf("URL must start with http:// or https:// %s!", src);
return -1;
}
croch = strstr(src, "[");
if (croch == NULL) return -1;
croch += 1;
croch2 = strstr(src, "]");
if (croch2 == NULL) return -1;
croch2 += 1;
colon = strstr(croch2, ":");
while (croch[pos] != ']' && pos < strlen(croch)) {
host[pos] = croch[pos];
pos++;
}
host[pos] = 0;
if (colon != NULL) sscanf(colon + 1, "%d", port);
return 0;
}
|
void pad_block(long param_1,undefined8 param_2,ulong param_3)
{
os_memset(param_1,0,AES_BLOCK_SIZE);
os_memcpy(param_1,param_2,param_3);
if (param_3 < AES_BLOCK_SIZE) {
*(undefined4 *)(param_1 + param_3 * 4) = 0x80;
}
return;
}
|
void pad_block(u8 *pad, const u8 *addr, size_t len)
{
os_memset(pad, 0, AES_BLOCK_SIZE);
os_memcpy(pad, addr, len);
if (len < AES_BLOCK_SIZE)
pad[len] = 0x80;
}
|
void demo_cpl_fn(undefined8 param_1,undefined4 *param_2,ulong param_3,undefined4 param_4)
{
int iVar1;
ulong uVar2;
undefined4 extraout_var;
uVar2 = start_of_path(param_3,param_4);
if (param_3 < uVar2) {
do {
iVar1 = isspace((uint)*(byte *)(uVar2 - 1));
if (CONCAT44(extraout_var,iVar1) == 0) goto LAB_00100047;
uVar2 = uVar2 - 1;
} while (param_3 != uVar2);
}
else {
LAB_00100047:
if (param_3 != uVar2) {
cpl_file_completions(param_1,0,param_3,param_4);
return;
}
}
pca_path_completions(param_1,*param_2,param_3,param_4);
return;
}
|
int (demo_cpl_fn)(WordCompletion *cpl, void *data, const char *line, int word_end)
{
DemoRes *res = (DemoRes *) data;
char *start = start_of_path(line, word_end);
while(start > line && isspace((int)(unsigned char) start[-1]))
start--;
return (start == line) ?
pca_path_completions(cpl, res->ppc, line, word_end) :
cpl_file_completions(cpl, NULL, line, word_end);
}
|
void add_symbol(undefined8 *param_1,undefined8 param_2)
{
long lVar1;
undefined8 *puVar2;
long lVar3;
void *pvVar4;
lVar3 = hash(param_2);
lVar1 = **(long **)*param_1;
pvVar4 = malloc(8);
*(void **)(lVar1 + lVar3 * 8) = pvVar4;
puVar2 = *(undefined8 **)(**(long **)*param_1 + lVar3 * 8);
if (puVar2 != (undefined8 *)0x0) {
*puVar2 = param_2;
return;
}
fprintf((FILE *)(ulong)stderr,"Error: Failed to allocate memory\n");
/* WARNING: Subroutine does not return */
exit(EXIT_FAILURE);
}
|
struct table_entry *add_symbol(struct token_stream *str, char *ch)
{
unsigned long position = hash((unsigned char *) ch);
str->context->recent_context->table[position] = malloc(sizeof(struct table_entry));
if(!str->context->recent_context->table[position]) {
fprintf(stderr, "Error: Failed to allocate memory\n");
exit(EXIT_FAILURE);
}
str->context->recent_context->table[position]->value = ch;
return str->context->recent_context->table[position];
}
|
void dump_data_hex(byte *param_1,int param_2)
{
byte *pbVar1;
byte bVar2;
printf("i2c: ");
if (0 < param_2) {
pbVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
bVar2 = *param_1;
param_1 = param_1 + 1;
printf("%x ",(ulong)bVar2);
} while (param_1 != pbVar1);
}
putchar(10);
return;
}
|
void dump_data_hex(unsigned char *buf, int size)
{
int i;
printf("i2c: ");
for (i = 0; i < size; i++)
printf("%x ", buf[i]);
printf("\n");
}
|
void in_pcb_conflict_post_msg(uint16_t param_1)
{
uint16_t uVar1;
undefined6 extraout_var;
long in_FS_OFFSET;
undefined4 *local_58;
undefined4 local_50;
undefined4 local_4c;
undefined4 local_48;
undefined4 local_44;
undefined local_38 [24];
undefined4 local_20;
undefined4 local_1c;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
bzero(local_38,0x20);
bzero(&local_58,0x20);
uVar1 = ntohs(param_1);
local_1c = (undefined4)CONCAT62(extraout_var,uVar1);
local_20 = proc_selfpid();
local_44 = KEV_VENDOR_APPLE;
local_48 = KEV_NETWORK_CLASS;
local_4c = KEV_INET_SUBCLASS;
local_50 = KEV_INET_PORTINUSE;
*(undefined **)(local_58 + 2) = local_38;
*local_58 = 0x20;
local_58[4] = 0;
dlil_post_complete_msg(0,&local_58);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
void
in_pcb_conflict_post_msg(u_int16_t port)
{
/*
* Radar 5523020 send a kernel event notification if a
* non-participating socket tries to bind the port a socket
* who has set SOF_NOTIFYCONFLICT owns.
*/
struct kev_msg ev_msg;
struct kev_in_portinuse in_portinuse;
bzero(&in_portinuse, sizeof (struct kev_in_portinuse));
bzero(&ev_msg, sizeof (struct kev_msg));
in_portinuse.port = ntohs(port); /* port in host order */
in_portinuse.req_pid = proc_selfpid();
ev_msg.vendor_code = KEV_VENDOR_APPLE;
ev_msg.kev_class = KEV_NETWORK_CLASS;
ev_msg.kev_subclass = KEV_INET_SUBCLASS;
ev_msg.event_code = KEV_INET_PORTINUSE;
ev_msg.dv[0].data_ptr = &in_portinuse;
ev_msg.dv[0].data_length = sizeof (struct kev_in_portinuse);
ev_msg.dv[1].data_length = 0;
dlil_post_complete_msg(NULL, &ev_msg);
}
|
void map_destroy(void **param_1)
{
void **ppvVar1;
ppvVar1 = (void **)*param_1;
if (ppvVar1[2] != (void *)0x0) {
map_destroy(ppvVar1 + 2);
ppvVar1 = (void **)*param_1;
}
if (ppvVar1[1] != (void *)0x0) {
map_destroy(ppvVar1 + 1);
ppvVar1 = (void **)*param_1;
}
free(*ppvVar1);
free(*param_1);
*param_1 = (void *)0x0;
return;
}
|
void map_destroy(pmap_t p_map)
{
if((*p_map)->p_left != NULL) {
map_destroy(&((*p_map)->p_left));
}
if((*p_map)->p_right != NULL) {
map_destroy(&((*p_map)->p_right));
}
free((*p_map)->key);
free(*p_map);
*p_map = NULL;
return;
}
|
undefined8 main(void)
{
char *pcVar1;
long in_FS_OFFSET;
char local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
PipcdInit();
setbuf((FILE *)(ulong)stdout,(char *)0x0);
while( true ) {
pcVar1 = fgets(local_118,0xff,(FILE *)(ulong)stdin);
if (pcVar1 == (char *)0x0) break;
PipcdDrawString(local_118);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
|
int main(){
PipcdInit();
setbuf(stdout, NULL);
char dat[255];
while(fgets(dat,255,stdin)){
PipcdDrawString(dat);
}
return 0;
}
|
undefined4 ideviceenterrecovery(void)
{
long in_FS_OFFSET;
undefined local_468 [80];
char local_418 [1032];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
system("clear");
printf("Enter UDID : ");
fget(local_468,0x50);
sprintf(local_418,"ideviceenterrecovery %s",local_468);
system(local_418);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return EXIT_SUCCESS;
}
|
int ideviceenterrecovery()
{
char buildCommand[1024];
char UDID[80];
system("clear");
printf("Enter UDID : ");
fget(UDID, 80);
sprintf(buildCommand, "ideviceenterrecovery %s", UDID);
system(buildCommand);
return EXIT_SUCCESS;
}
|
undefined8 undefined_2701(void)
{
return *(undefined8 *)(functions + 0x5468);
}
|
void* undefined_2701 () { return (void*)functions[2701].pointer; }
|
undefined8 need_value(undefined8 param_1,int param_2)
{
uint *puVar1;
long lVar2;
if (param_2 == -1) {
return 0;
}
do {
puVar1 = (uint *)getjumpcontrol(param_1,param_2);
lVar2 = cast(OpCode,*puVar1 & 0x3f);
if (lVar2 != OP_TESTSET) {
return 1;
}
param_2 = getjump(param_1,param_2);
} while (param_2 != -1);
return 0;
}
|
int need_value (FuncState *fs, int list) {
for (; list != (-1); list = getjump(fs, list)) {
Instruction i = *getjumpcontrol(fs, list);
if ((cast(OpCode, ((i)>>0) & ((~((~(Instruction)0)<<6))<<0))) != OP_TESTSET) return 1;
}
return 0;
}
|
undefined8 delaySleep(int param_1,__pid_t param_2)
{
int iVar1;
undefined4 extraout_var;
uint uVar2;
ulong uVar3;
if (param_1 * 0x3c < 1) {
uVar3 = 0;
}
else {
uVar2 = 0;
do {
iVar1 = kill(param_2,SIGUSR2);
if (CONCAT44(extraout_var,iVar1) != 0) {
fprintf((FILE *)(ulong)stderr,"Failed to signal for sleep delay\n");
return 0xffffffff;
}
uVar2 = uVar2 + 600;
usleep(20000);
} while (SBORROW4(uVar2,param_1 * 0x3c) != (int)(uVar2 + param_1 * -0x3c) < 0);
uVar3 = (ulong)uVar2 / 0x3c;
}
printf("delayed sleep by %d minutes\n",uVar3);
return 0;
}
|
int delaySleep(int minutes, pid_t pid) {
int mins;
for(mins=0; mins < (minutes*60); mins += 600) {
if(kill(pid, SIGUSR2) != 0) {
fprintf(stderr, "Failed to signal for sleep delay\n");
return -1;
}
usleep(20000);
}
printf("delayed sleep by %d minutes\n", mins/60);
return 0;
}
|
void clear_subtree(void **param_1)
{
void **ppvVar1;
if (param_1 == (void **)0x0) {
return;
}
do {
ppvVar1 = (void **)param_1[3];
param_1[2] = (void *)0x0;
param_1[1] = (void *)0x0;
free(*param_1);
free(param_1);
param_1 = ppvVar1;
} while (ppvVar1 != (void **)0x0);
return;
}
|
void
clear_subtree(fpgsubtreePtr stree)
{
fpgsubtreePtr ts;
while (stree != NULL) {
ts = stree;
stree = stree->next;
ts->item_name = 0;
ts->item_count = 0;
free(ts->parent);
free(ts);
}
}
|
void test_comment(undefined4 param_1,undefined4 param_2,undefined8 param_3)
{
undefined4 uVar1;
int iVar2;
long lVar3;
uVar1 = FPAddComment(Conn,param_1,param_2,param_3,"essai");
lVar3 = not_valid(uVar1,0,0xffffec78);
if (lVar3 != 0) {
failed();
}
iVar2 = FPRemoveComment(Conn,param_1,param_2,param_3);
lVar3 = not_valid(iVar2,0,0xffffec78);
if (lVar3 != 0) {
failed();
}
if (iVar2 != 0) {
return;
}
FPAddComment(Conn,param_1,param_2,param_3,"essai");
return;
}
|
void test_comment(uint16_t vol, int dir, char *name)
{
int ret;
ret = FPAddComment(Conn, vol, dir, name, "essai");
if (not_valid(ret, 0, -5000)) {
failed();
}
ret = FPRemoveComment(Conn, vol, dir , name);
if (not_valid(ret, 0, -5000)) {
failed();
}
if (!ret) {
FPAddComment(Conn, vol, dir , name,"essai");
}
}
|
void i2c1_ClearSTAT(undefined param_1)
{
i2c_ClearSTAT(1,param_1);
return;
}
|
void i2c1_ClearSTAT(unsigned char i2cstats) {
i2c_ClearSTAT(1, i2cstats);
}
|
undefined8 mc_set_global_enables(int *param_1,undefined4 *param_2)
{
if (*param_1 == 1) {
mc_global_enables = **(undefined4 **)(param_1 + 2);
*param_2 = 0;
return 0;
}
*param_2 = 199;
return 0xffffffff;
}
|
int
mc_set_global_enables(struct dummy_rq *req, struct dummy_rs *rsp)
{
if (req->msg.data_len != 1) {
rsp->ccode = 0xC7;
return (-1);
}
mc_global_enables = req->msg.data[0];
rsp->ccode = 0x00;
return 0;
}
|
void stmmac_disable_eee_mode(undefined4 *param_1)
{
stmmac_reset_eee_mode(param_1,param_1[2]);
del_timer_sync(param_1 + 1);
*param_1 = 0;
return;
}
|
void stmmac_disable_eee_mode(struct stmmac_priv *priv)
{
stmmac_reset_eee_mode(priv, priv->hw);
del_timer_sync(&priv->eee_ctrl_timer);
priv->tx_path_in_lpi_mode = false;
}
|
void InsertChild(undefined4 param_1)
{
long *plVar1;
long lVar2;
long lVar3;
(**compositeWidgetClass)();
plVar1 = (long *)XtParent(param_1);
lVar3 = *plVar1;
if (lVar3 == plVar1[1]) {
lVar2 = Marraygrow(plVar1[2],lVar3 * 4 + 0x28);
plVar1[1] = plVar1[1] + 10;
lVar3 = *plVar1;
plVar1[2] = lVar2;
}
else {
lVar2 = plVar1[2];
}
*plVar1 = lVar3 + 1;
*(undefined4 *)(lVar2 + lVar3 * 4) = param_1;
return;
}
|
void InsertChild (Widget w) {
ArrayWidget aw;
CompositeWidgetClass sclass;
sclass = (CompositeWidgetClass) compositeWidgetClass;
(*sclass->composite_class.insert_child) (w);
aw = (ArrayWidget) XtParent (w);
if (aw->array.data.cj == aw->array.data.cn) {
aw->array.data.carray = Marraygrow (
aw->array.data.carray,
(long) (aw->array.data.cn + 10) * sizeof (Gawcarray_t)
);
aw->array.data.cn += 10;
}
aw->array.data.carray[aw->array.data.cj++].w = w;
}
|
void deleteserver(long param_1)
{
long *plVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
lVar5 = param_1 * 0x20;
lVar2 = serverlist;
lVar3 = 0;
if (*(long *)(serverlist + 0x18 + lVar5) == 0) {
Error("server",2,"Tried to remove server %ld which doesn\'t exist.",param_1);
return;
}
do {
while ((plVar1 = (long *)(lVar3 * 0x20 + lVar2), *plVar1 == param_1 && (plVar1[3] != 0))) {
lVar4 = lVar3 + 1;
deleteserver(lVar3);
lVar2 = serverlist;
lVar3 = lVar4;
if (lVar4 == 0x1000) goto LAB_0010006f;
}
lVar3 = lVar3 + 1;
} while (lVar3 != 0x1000);
LAB_0010006f:
Error("server",0,"Setting link state on %s to LS_SQUIT",**(undefined8 **)(lVar2 + 0x18 + lVar5));
*(undefined4 *)(serverlist + 8 + lVar5) = 4;
triggerhook(0xcb,param_1);
triggerhook(0xc9);
freesstring(*(undefined8 *)(serverlist + 0x18 + lVar5));
freesstring(*(undefined8 *)(serverlist + 0x10 + lVar5));
memset((void *)(serverlist + lVar5),0,4);
return;
}
|
void deleteserver(long servernum) {
int i;
if (serverlist[servernum].name==NULL) {
Error("server",2,"Tried to remove server %ld which doesn't exist.",servernum);
return;
}
for (i=0;i<4096;i++) {
if (serverlist[i].parent==servernum && serverlist[i].name!=NULL) {
deleteserver(i);
}
}
Error("server",0,"Setting link state on %s to LS_SQUIT",serverlist[servernum].name->content);
serverlist[servernum].linkstate=4;
triggerhook(203,(void *)servernum);
triggerhook(201,(void *)servernum);
freesstring(serverlist[servernum].name);
freesstring(serverlist[servernum].description);
memset(&(serverlist[servernum]),0,sizeof(server));
}
|
void EventDel(int param_1,int *param_2)
{
long in_FS_OFFSET;
int *local_28;
epoll_data_t local_20;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = (int *)0x0;
local_20.ptr = (void *)0x0;
if (*param_2 == 1) {
*param_2 = 0;
local_28 = param_2;
epoll_ctl(param_1,EPOLL_CTL_DEL,param_2[1],(epoll_event *)&local_28);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
void EventDel(int epollFd, myevent_s *ev)
{
struct epoll_event epv = {0, {0}};
if(ev->status != 1) return;
epv.data.ptr = ev;
ev->status = 0;
epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);
}
|
char * scanarg(char *param_1,char param_2)
{
char cVar1;
char *pcVar2;
char *pcVar3;
int iVar4;
cVar1 = *param_1;
pcVar3 = param_1 + 1;
while( true ) {
while( true ) {
pcVar2 = pcVar3;
if (param_2 == cVar1) {
*param_1 = '\0';
return pcVar2;
}
if ((cVar1 == '\\') && (param_1[1] == 'x')) break;
cVar1 = *pcVar2;
pcVar3 = pcVar2 + 1;
param_1 = pcVar2;
}
iVar4 = isxdigit((int)param_1[2]);
if (iVar4 == 0) break;
iVar4 = isxdigit((int)param_1[3]);
if (iVar4 == 0) {
return (char *)0x0;
}
cVar1 = param_1[4];
pcVar3 = param_1 + 5;
param_1 = param_1 + 4;
}
return (char *)0x0;
}
|
char *scanarg(char *s, char del)
{
char c;
while ((c = *s++) != del) {
if (c == '\\' && *s == 'x') {
s++;
if (!isxdigit(*s++))
return NULL;
if (!isxdigit(*s++))
return NULL;
}
}
s[-1] ='\0';
return s;
}
|
undefined8 rds_ib_update_ipaddr(long param_1,long *param_2)
{
long lVar1;
undefined8 uVar2;
lVar1 = rds_ib_get_device(*(undefined4 *)(*param_2 + 0xc));
if (lVar1 != 0) {
if (lVar1 == param_1) {
rds_ib_dev_put(lVar1);
return 0;
}
rds_ib_remove_ipaddr(lVar1,*(undefined4 *)(*param_2 + 0xc));
rds_ib_dev_put(lVar1);
}
uVar2 = rds_ib_add_ipaddr(param_1,*(undefined4 *)(*param_2 + 0xc));
return uVar2;
}
|
int rds_ib_update_ipaddr(struct rds_ib_device *rds_ibdev,
struct in6_addr *ipaddr)
{
struct rds_ib_device *rds_ibdev_old;
rds_ibdev_old = rds_ib_get_device(ipaddr->s6_addr32[3]);
if (!rds_ibdev_old)
return rds_ib_add_ipaddr(rds_ibdev, ipaddr->s6_addr32[3]);
if (rds_ibdev_old != rds_ibdev) {
rds_ib_remove_ipaddr(rds_ibdev_old, ipaddr->s6_addr32[3]);
rds_ib_dev_put(rds_ibdev_old);
return rds_ib_add_ipaddr(rds_ibdev, ipaddr->s6_addr32[3]);
}
rds_ib_dev_put(rds_ibdev_old);
return 0;
}
|
undefined8 peekSet(undefined8 *param_1)
{
if (param_1 != (undefined8 *)0x0) {
return *param_1;
}
return 0;
}
|
void *peekSet(const set *sp) {
if (!sp)
return NULL;
return sp->item;
}
|
undefined4 bayrad_cellheight(undefined8 *param_1)
{
return *(undefined4 *)*param_1;
}
|
int
bayrad_cellheight(Driver *drvthis)
{
PrivateData *p = drvthis->private_data;
return p->cellheight;
}
|
void shortValueFromNext(FILE *param_1)
{
long in_FS_OFFSET;
undefined2 local_12;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
fread(&local_12,2,1,param_1);
CFSwapInt16(local_12);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
unsigned short shortValueFromNext(FILE *file)
{
unsigned short retValue;
fread(&retValue, 2, 1, file);
retValue = CFSwapInt16(retValue);
return retValue;
}
|
void mat4d_rotateAxisVec_new(undefined8 param_1)
{
long in_FS_OFFSET;
undefined auStack_68 [72];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
mat3d_rotateAxisVec_new(auStack_68);
mat4d_from_mat3d(param_1,auStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void mat4d_rotateAxisVec_new(double result[16], double degrees, const double axis[3])
{
double tmpMat[9];
mat3d_rotateAxisVec_new(tmpMat, degrees, axis);
mat4d_from_mat3d(result, tmpMat);
}
|
void * rgb888_to_rgb565_buffer(long param_1,int param_2,int param_3)
{
void *__ptr;
long lVar1;
if (((param_1 != 0 && 0 < param_3) && (0 < param_2)) &&
(__ptr = malloc((ulong)((param_2 * 2 + 3U & 0xfffffffc) * param_3)), __ptr != (void *)0x0)) {
lVar1 = rgb888_to_rgb565(param_1,param_2,param_3,__ptr);
if (lVar1 == 0) {
return __ptr;
}
free(__ptr);
}
return (void *)0x0;
}
|
void * rgb888_to_rgb565_buffer(const void * psrc, int w, int h)
{
int size = h * (((w * 2) + 3) & ~3);
void * pdst = NULL;
if (psrc && w > 0 && h > 0) {
pdst = malloc(size);
if (pdst) {
if (rgb888_to_rgb565(psrc, w, h, pdst)) {
free(pdst);
pdst = NULL;
}
}
}
return pdst;
}
|
void _init_mp_priv_(undefined8 *param_1)
{
undefined4 uVar1;
uVar1 = _LOOPBOOK_MODE_;
param_1[6] = 0;
*(undefined (*) [16])(param_1 + 1) = (undefined [16])0x0;
*(undefined4 *)((long)param_1 + 0x3c) = uVar1;
uVar1 = MIXED_PHY;
*(undefined (*) [16])(param_1 + 3) = (undefined [16])0x0;
*(undefined4 *)(param_1 + 7) = uVar1;
*(undefined4 *)((long)param_1 + 0x2c) = ANTENNA_A;
*(undefined4 *)(param_1 + 5) = ANTENNA_AB;
*param_1 = 0x1400000001;
return;
}
|
void _init_mp_priv_(struct mp_priv *pmp_priv)
{
pmp_priv->mode = _LOOPBOOK_MODE_;
pmp_priv->curr_ch = 1;
pmp_priv->curr_modem = MIXED_PHY;
pmp_priv->curr_rateidx = 0;
pmp_priv->curr_txpoweridx = 0x14;
pmp_priv->antenna_tx = ANTENNA_A;
pmp_priv->antenna_rx = ANTENNA_AB;
pmp_priv->check_mp_pkt = 0;
pmp_priv->tx_pktcount = 0;
pmp_priv->rx_pktcount = 0;
pmp_priv->rx_crcerrpktcount = 0;
}
|
void gui_window_scroll_next_highlight(long **param_1)
{
long *plVar1;
undefined8 *puVar2;
if ((((param_1 != (long **)0x0) && (plVar1 = *param_1, *plVar1 == GUI_BUFFER_TYPE_FORMATTED)) &&
(plVar1[1] == 0)) && (*(undefined8 **)plVar1[2] != (undefined8 *)0x0)) {
puVar2 = (undefined8 *)param_1[1][1];
if (puVar2 == (undefined8 *)0x0) {
puVar2 = *(undefined8 **)plVar1[2];
}
puVar2 = (undefined8 *)*puVar2;
while( true ) {
if (puVar2 == (undefined8 *)0x0) {
gui_window_scroll_bottom();
return;
}
if (*(long *)puVar2[1] != 0) break;
puVar2 = (undefined8 *)*puVar2;
}
param_1[1][1] = (long)puVar2;
param_1[1][2] = 0;
*(uint *)param_1[1] = (uint)(*(long *)(*param_1)[2] == param_1[1][1]);
gui_buffer_ask_chat_refresh(*param_1,2);
return;
}
return;
}
|
void
gui_window_scroll_next_highlight (struct t_gui_window *window)
{
struct t_gui_line *ptr_line;
if (!window)
return;
if ((window->buffer->type == GUI_BUFFER_TYPE_FORMATTED)
&& (window->buffer->text_search == 0))
{
if (window->buffer->lines->first_line)
{
ptr_line = (window->scroll->start_line) ?
window->scroll->start_line->next_line : window->buffer->lines->first_line->next_line;
while (ptr_line)
{
if (ptr_line->data->highlight)
{
window->scroll->start_line = ptr_line;
window->scroll->start_line_pos = 0;
window->scroll->first_line_displayed =
(window->scroll->start_line == window->buffer->lines->first_line);
gui_buffer_ask_chat_refresh (window->buffer, 2);
return;
}
ptr_line = ptr_line->next_line;
}
gui_window_scroll_bottom (window);
}
}
}
|
undefined4 main(int param_1,long param_2)
{
size_t sVar1;
undefined4 uVar2;
long in_FS_OFFSET;
char acStack_128 [264];
long local_20;
uVar2 = EXIT_FAILURE;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 == 2) {
sVar1 = strlen(*(char **)(param_2 + 8));
if ((byte)sVar1 < 0xfe) {
printf("size = %d\n",sVar1 & 0xff);
strcpy(acStack_128,*(char **)(param_2 + 8));
uVar2 = EXIT_SUCCESS;
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int main (int argc, char **argv)
{
int ret = EXIT_FAILURE;
if (argc == 2)
{
char buf[255];
unsigned char size = strlen (argv[1]);
if (size < 254)
{
printf ("size = %d\n", size);
strcpy (buf, argv[1]);
ret = EXIT_SUCCESS;
}
}
return ret;
}
|
void rtl88ee_disable_interrupt(undefined8 param_1)
{
undefined8 uVar1;
undefined4 *puVar2;
undefined4 uVar3;
uVar1 = rtl_priv();
uVar3 = rtl_pcipriv(param_1);
puVar2 = (undefined4 *)rtl_pcidev(uVar3);
rtl_write_dword(uVar1,REG_HIMR,IMR_DISABLED);
rtl_write_dword(uVar1,REG_HIMRE,IMR_DISABLED);
*puVar2 = 0;
return;
}
|
void rtl88ee_disable_interrupt(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
rtl_write_dword(rtlpriv, REG_HIMR, IMR_DISABLED);
rtl_write_dword(rtlpriv, REG_HIMRE, IMR_DISABLED);
rtlpci->irq_enabled = false;
/*synchronize_irq(rtlpci->pdev->irq);*/
}
|
undefined8 notracks_cb(int param_1)
{
tracks_id = pmalloc(param_1 << 2);
return 0;
}
|
int notracks_cb(unsigned int num, void *user)
{
tracks_id = pmalloc(num * 4);
return 0;
}
|
void iprint(uint param_1,undefined8 param_2,int param_3,int param_4)
{
long lVar1;
long in_FS_OFFSET;
undefined local_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = ufmt(((int)param_1 >> 0x1f ^ param_1) - ((int)param_1 >> 0x1f),param_2,local_38);
if ((int)param_1 < 0) {
if (param_4 == 0x30) {
dputc(0x2d);
param_3 = param_3 + -1;
}
else {
*(undefined *)(lVar1 + -1) = 0x2d;
lVar1 = lVar1 + -1;
}
}
nprint(lVar1,local_38,param_3,param_4);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void iprint(int v, unsigned int base, unsigned int width, int pad) {
char buffer[33], *e = buffer+32, *p;
unsigned int u;
u = v > 0 ? v : -v;
p = ufmt(u, base, e);
if (v < 0) {
if (pad == '0') {
dputc('-');
width-=1;
} else {
*--p = '-';
}
}
nprint(p, e, width, pad);
}
|
void p256_point_mul(undefined8 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4,
undefined8 param_5)
{
to_montgomery(0);
to_montgomery(0,param_3);
scalar_mult(0,0,0,0,0,param_1);
point_to_affine(0,0,0,0,0);
from_montgomery(param_4,0);
from_montgomery(param_5,0);
return;
}
|
void p256_point_mul(const p256_int* n, const p256_int* in_x,
const p256_int* in_y, p256_int* out_x, p256_int* out_y) {
felem x, y, z, px, py;
to_montgomery(px, in_x);
to_montgomery(py, in_y);
scalar_mult(x, y, z, px, py, n);
point_to_affine(px, py, x, y, z);
from_montgomery(out_x, px);
from_montgomery(out_y, py);
}
|
void iio_dma_buffer_block_done(long *param_1)
{
long lVar1;
undefined8 local_10;
lVar1 = *param_1;
spin_lock_irqsave(lVar1 + 4,local_10);
_iio_dma_buffer_block_done(param_1);
spin_unlock_irqrestore(lVar1 + 4,local_10);
iio_buffer_block_put_atomic(param_1);
wake_up_interruptible_poll(lVar1,EPOLLIN | EPOLLRDNORM);
return;
}
|
void iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)
{
struct iio_dma_buffer_queue *queue = block->queue;
unsigned long flags;
spin_lock_irqsave(&queue->list_lock, flags);
_iio_dma_buffer_block_done(block);
spin_unlock_irqrestore(&queue->list_lock, flags);
iio_buffer_block_put_atomic(block);
wake_up_interruptible_poll(&queue->buffer.pollq, EPOLLIN | EPOLLRDNORM);
}
|
undefined4 rbfs_rewind(undefined4 *param_1,undefined8 *param_2)
{
*(undefined4 *)(param_2 + 2) = *(undefined4 *)((long)param_2 + 0xc);
*(undefined4 *)(param_2 + 1) = *param_1;
*param_2 = 0;
_rbfs_check_for_eor_reached(param_2);
return RBFS_OP_RESULT_SUCCESS;
}
|
rbfs_op_result_t rbfs_rewind(rbfs_t *rbfs, rbfs_resource_t *resource) {
resource->current_cluster = resource->first_cluster;
resource->cluster_offset = rbfs->sizeof_cluster_control;
resource->current_position = 0;
_rbfs_check_for_eor_reached(resource);
return RBFS_OP_RESULT_SUCCESS;
}
|
undefined4 madera_thermal_warn(undefined8 param_1,undefined4 *param_2)
{
uint uVar1;
int iVar2;
undefined4 uVar3;
long in_FS_OFFSET;
int local_18;
uint local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = madera_check_speaker_overheat(param_2,&local_18,&local_14);
if ((uVar1 | local_14) == 0) {
if (local_18 == 0) {
dev_info(*param_2,"Spurious thermal warning\n");
uVar3 = IRQ_NONE;
}
else {
dev_alert(*param_2,"Thermal warning\n");
uVar3 = IRQ_HANDLED;
}
}
else {
dev_crit(*param_2,"Thermal shutdown\n");
iVar2 = regmap_update_bits(param_2[1],MADERA_OUTPUT_ENABLES_1,
MADERA_OUT4L_ENA | MADERA_OUT4R_ENA,0);
uVar3 = IRQ_HANDLED;
if (iVar2 != 0) {
dev_crit(*param_2,"Failed to disable speaker outputs: %d\n",iVar2);
uVar3 = IRQ_HANDLED;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
|
irqreturn_t madera_thermal_warn(int irq, void *data)
{
struct madera *madera = data;
bool warn, shutdown;
int ret;
ret = madera_check_speaker_overheat(madera, &warn, &shutdown);
if (ret || shutdown) { /* for safety attempt to shutdown on error */
dev_crit(madera->dev, "Thermal shutdown\n");
ret = regmap_update_bits(madera->regmap,
MADERA_OUTPUT_ENABLES_1,
MADERA_OUT4L_ENA |
MADERA_OUT4R_ENA, 0);
if (ret != 0)
dev_crit(madera->dev,
"Failed to disable speaker outputs: %d\n",
ret);
} else if (warn) {
dev_alert(madera->dev, "Thermal warning\n");
} else {
dev_info(madera->dev, "Spurious thermal warning\n");
return IRQ_NONE;
}
return IRQ_HANDLED;
}
|
void ft_putnbr_fd(int param_1,undefined4 param_2)
{
if (param_1 < 0) {
if (param_1 == -0x80000000) {
ft_putstr_fd("-2147483648");
return;
}
ft_putchar_fd(0x2d);
param_1 = -param_1;
}
if (param_1 < 10) {
ft_putchar_fd(param_1 + 0x30,param_2);
}
else {
ft_putnbr_fd(param_1 / 10,param_2);
ft_putnbr_fd(param_1 % 10,param_2);
}
return;
}
|
void ft_putnbr_fd(int n, int fd)
{
if (n < 0)
{
if (n == -2147483648)
{
ft_putstr_fd("-2147483648", fd);
return ;
}
else
{
ft_putchar_fd('-', fd);
n = n * -1;
}
}
if (n > 9)
{
ft_putnbr_fd(n / 10, fd);
ft_putnbr_fd(n % 10, fd);
}
else
ft_putchar_fd(n + 48, fd);
}
|
void ooaofooa_O_TPARM_R124_Unlink_succeeds(long param_1,undefined8 *param_2)
{
param_2[2] = 0;
*(undefined8 *)(param_1 + 8) = 0;
*param_2 = 0;
return;
}
|
void
ooaofooa_O_TPARM_R124_Unlink_succeeds( ooaofooa_O_TPARM * left, ooaofooa_O_TPARM * right )
{
right->Previous_TParm_ID = 0;
left->O_TPARM_R124_succeeds = 0;
right->O_TPARM_R124_precedes = 0;
}
|
uint find_last_group(undefined4 *param_1,int param_2)
{
undefined4 uVar1;
byte bVar2;
undefined4 uVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
uint uVar9;
uVar1 = *param_1;
uVar3 = **(undefined4 **)(param_1 + 2);
bVar2 = (byte)uVar3;
iVar7 = 1 << (bVar2 - (char)uVar1 & 0x1f);
iVar8 = iVar7 + -1;
if (-1 < iVar8) {
iVar6 = 0;
while( true ) {
iVar5 = iVar6 + iVar8 >> 1;
uVar9 = iVar5 << ((byte)uVar1 & 0x1f) | param_2 << ((byte)uVar3 & 0x1f);
lVar4 = cp_free(param_1,uVar9);
if (lVar4 == 0) {
iVar6 = iVar5 + 1;
if (iVar7 <= iVar6) {
return uVar9;
}
lVar4 = cp_free(param_1,(1 << ((byte)*param_1 & 0x1f)) + uVar9);
if (lVar4 != 0) {
return uVar9;
}
}
else {
iVar8 = iVar5 + -1;
}
uVar3 = **(undefined4 **)(param_1 + 2);
bVar2 = (byte)uVar3;
if (iVar8 < iVar6) break;
uVar1 = *param_1;
}
}
return param_2 << (bVar2 & 0x1f);
}
|
dhara_page_t find_last_group(struct dhara_journal *j,
dhara_block_t blk)
{
const int num_groups = 1 << (j->nand->log2_ppb - j->log2_ppc);
int low = 0;
int high = num_groups - 1;
while (low <= high) {
int mid = (low + high) >> 1;
const dhara_page_t p = (mid << j->log2_ppc) |
(blk << j->nand->log2_ppb);
if (cp_free(j, p)) {
high = mid - 1;
} else if (((mid + 1) >= num_groups) ||
cp_free(j, p + (1 << j->log2_ppc))) {
return p;
} else {
low = mid + 1;
}
}
return blk << j->nand->log2_ppb;
}
|
undefined4 delete_client(int *param_1,long param_2)
{
undefined4 uVar1;
int iVar2;
if ((param_1 == (int *)0x0) || (param_2 < 1)) {
uVar1 = 0;
}
else {
uVar1 = 1;
}
assert(uVar1);
iVar2 = find_client(param_1,param_2);
uVar1 = ERR_INTERNAL;
if (iVar2 != -1) {
*(undefined8 *)(*(long *)(param_1 + 2) + (long)iVar2 * 8) = 0;
*param_1 = *param_1 + 1;
uVar1 = 0;
}
return uVar1;
}
|
int
delete_client( struct server_ctx* ctx, pid_t cpid )
{
struct client_ctx* client = NULL;
int index = -1;
assert( ctx && (cpid > 0) );
index = find_client( ctx, cpid );
if( -1 == index ) {
return ERR_INTERNAL;
}
client = &(ctx->cl[ index ]);
client->pid = 0;
ctx->clfree++;
if( g_flog ) {
((void)0);
}
return 0;
}
|
uint __rdma_block_iter_next(uint *param_1)
{
int iVar1;
int iVar2;
int iVar3;
long lVar4;
undefined8 uVar5;
uint uVar6;
uint uVar7;
uVar6 = param_1[2];
if (uVar6 != 0) {
uVar6 = 0;
if (*(long *)(param_1 + 4) != 0) {
iVar1 = sg_dma_address();
uVar6 = param_1[1];
*param_1 = iVar1 + uVar6;
iVar2 = BIT_ULL(param_1[6]);
iVar3 = BIT_ULL(param_1[6]);
uVar7 = (iVar3 + param_1[1]) - (iVar2 - 1U & iVar1 + uVar6);
param_1[1] = uVar7;
lVar4 = sg_dma_len(*(undefined8 *)(param_1 + 4));
uVar6 = 1;
if (lVar4 <= (int)uVar7) {
param_1[1] = 0;
uVar5 = sg_next(*(undefined8 *)(param_1 + 4));
param_1[2] = param_1[2] - 1;
*(undefined8 *)(param_1 + 4) = uVar5;
return 1;
}
}
}
return uVar6;
}
|
bool __rdma_block_iter_next(struct ib_block_iter *biter)
{
unsigned int block_offset;
if (!biter->__sg_nents || !biter->__sg)
return false;
biter->__dma_addr = sg_dma_address(biter->__sg) + biter->__sg_advance;
block_offset = biter->__dma_addr & (BIT_ULL(biter->__pg_bit) - 1);
biter->__sg_advance += BIT_ULL(biter->__pg_bit) - block_offset;
if (biter->__sg_advance >= sg_dma_len(biter->__sg)) {
biter->__sg_advance = 0;
biter->__sg = sg_next(biter->__sg);
biter->__sg_nents--;
}
return true;
}
|
void shlib_maincall(void)
{
main_called();
return;
}
|
int
shlib_maincall ()
{
return main_called ();
}
|
void writeCIPredMode_CABAC(int *param_1,undefined8 *param_2)
{
undefined8 *puVar1;
long *plVar2;
long *plVar3;
int iVar4;
int iVar5;
long **pplVar6;
uint uVar7;
long lVar8;
puVar1 = param_2 + 1;
iVar4 = arienco_bits_written(puVar1);
iVar5 = *param_1;
plVar2 = *(long **)img[2];
pplVar6 = (long **)(*img * 0x10 + img[1]);
uVar7 = 0;
plVar3 = pplVar6[1];
if (plVar3 != (long *)0x0) {
uVar7 = (uint)(*plVar3 != 0);
}
plVar3 = *pplVar6;
if (plVar3 != (long *)0x0) {
uVar7 = uVar7 + (*plVar3 != 0);
}
lVar8 = (long)(int)uVar7 + *plVar2;
if (iVar5 == 0) {
biari_encode_symbol(puVar1,0,lVar8);
}
else {
biari_encode_symbol(puVar1,1,lVar8);
unary_bin_max_encode(puVar1,iVar5 + -1,*plVar2 + 3,0,2);
}
*(undefined4 *)*param_2 = 1;
iVar5 = arienco_bits_written(puVar1);
param_1[1] = iVar5 - iVar4;
return;
}
|
void writeCIPredMode_CABAC(SyntaxElement *se, DataPartition *dp)
{
EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
int curr_len = arienco_bits_written(eep_dp);
TextureInfoContexts *ctx = img->currentSlice->tex_ctx;
Macroblock *currMB = &img->mb_data[img->current_mb_nr];
int act_ctx,a,b;
int act_sym = se->value1;
if (currMB->mb_available_up == NULL) b = 0;
else b = ( ((currMB->mb_available_up)->c_ipred_mode != 0) ? 1 : 0);
if (currMB->mb_available_left == NULL) a = 0;
else a = ( ((currMB->mb_available_left)->c_ipred_mode != 0) ? 1 : 0);
act_ctx = a+b;
if (act_sym==0)
biari_encode_symbol(eep_dp, 0, ctx->cipr_contexts + act_ctx );
else
{
biari_encode_symbol(eep_dp, 1, ctx->cipr_contexts + act_ctx );
unary_bin_max_encode(eep_dp,(unsigned int) (act_sym-1),ctx->cipr_contexts+3,0,2);
}
dp->bitstream->write_flag = 1;
se->len = (arienco_bits_written(eep_dp) - curr_len);
;
return;
}
|
undefined8 get_firstinitial(undefined8 param_1)
{
int iVar1;
undefined8 uVar2;
iVar1 = fields_find(param_1,"AUTHOR",0);
if ((iVar1 == -1) && (iVar1 = fields_find(param_1,"AUTHOR",0xffffffff), iVar1 == -1)) {
return 0;
}
uVar2 = fields_value(param_1,iVar1,0x10);
uVar2 = initial_ascii(uVar2);
return uVar2;
}
|
char
get_firstinitial( fields *in )
{
char *name;
int n;
n = fields_find( in, "AUTHOR", (0) );
if ( n==(-1) ) n = fields_find( in, "AUTHOR", (-1) );
if ( n!=(-1) ) {
name = fields_value( in, n, ((16) ) );
return initial_ascii( name );
} else return '\0';
}
|
ulong rtl8367c_setAsicCputagPriorityRemapping(int param_1,int param_2)
{
ulong uVar1;
if ((param_1 < 8) && (param_2 < 8)) {
uVar1 = rtl8367c_setAsicRegBits
((param_1 >> 2) + RTL8367C_REG_QOS_PRIORITY_REMAPPING_IN_CPU_CTRL0,
RTL8367C_QOS_PRIORITY_REMAPPING_IN_CPU_CTRL0_PRIORITY0_MASK <<
((char)param_1 * '\x04' & 0xcU),param_2);
return uVar1;
}
return (ulong)RT_ERR_QOS_INT_PRIORITY;
}
|
ret_t rtl8367c_setAsicCputagPriorityRemapping(rtk_uint32 srcPri, rtk_uint32 newPri)
{
if((srcPri > 7) || (newPri > 7))
return RT_ERR_QOS_INT_PRIORITY;
return rtl8367c_setAsicRegBits((RTL8367C_REG_QOS_PRIORITY_REMAPPING_IN_CPU_CTRL0 + (srcPri >> 2)), (RTL8367C_QOS_PRIORITY_REMAPPING_IN_CPU_CTRL0_PRIORITY0_MASK << ((srcPri & 0x3) << 2)), newPri);
}
|
void USART_SetDEAssertionTime(uint *param_1,int param_2)
{
undefined4 uVar1;
uVar1 = IS_USART_ALL_PERIPH();
assert_param(uVar1);
uVar1 = IS_USART_DE_ASSERTION_DEASSERTION_TIME(param_2);
assert_param(uVar1);
*param_1 = ~(uint)USART_CR1_DEAT & *param_1 | param_2 << 0x15;
return;
}
|
void USART_SetDEAssertionTime(USART_TypeDef* USARTx, uint32_t USART_DEAssertionTime)
{
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_USART_DE_ASSERTION_DEASSERTION_TIME(USART_DEAssertionTime));
/* Clear the DE assertion time */
USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_DEAT);
/* Set the new value for the DE assertion time */
USARTx->CR1 |=((uint32_t)USART_DEAssertionTime << (uint32_t)0x15);
}
|
void usage(void)
{
printf("Usage: %s <record-type> <domain-name>\n",prog);
return;
}
|
void
usage (void)
{
printf ("Usage: %s <record-type> <domain-name>\n", prog);
}
|
undefined8 m2m_cmp_cooc(int *param_1,int *param_2)
{
undefined8 uVar1;
if (*param_1 == *param_2) {
if (param_1[8] == param_2[8]) {
uVar1 = 0;
}
else if (param_1[8] < param_2[8]) {
uVar1 = 0xffffffff;
}
else {
uVar1 = 1;
}
}
else if (*param_1 < *param_2) {
uVar1 = 0xffffffff;
}
else {
uVar1 = 1;
}
return uVar1;
}
|
Z32 m2m_cmp_cooc ( Z32 *a, Z32 *b, hitdef *hit_def, Z32 level )
{
N32 i = 0;
hitcmp *h = hit_def->levels+level;
if ( a[0] != b[0] )
return a[0] < b[0] ? -1 : 1;
i = h->r_context;
i = 7 + 1;
if ( a[i] != b[i] )
return a[i] < b[i] ? -1 : 1;
return 0;
}
|
undefined8 getLanguageFileKind(long param_1)
{
return **(undefined8 **)(LanguageTable + param_1 * 8);
}
|
extern kindOption* getLanguageFileKind (const langType language)
{
kindOption* kind;
;
kind = LanguageTable [language]->fileKind;
;
return kind;
}
|
bool test_four_ways(void)
{
int iVar1;
bool bVar2;
iVar1 = change(denom,4,7);
bVar2 = false;
if (iVar1 == 4) {
iVar1 = change_dyn(denom,4,7);
bVar2 = iVar1 == 4;
}
return bVar2;
}
|
int test_four_ways() {
return 4 == change(denom, 4, 7) &&
4 == change_dyn(denom, 4, 7);
}
|
void set_kHZ(undefined4 param_1)
{
kHZ = param_1;
return;
}
|
void set_kHZ(uint64_t val) {
kHZ = val;
}
|
undefined4 chess_alloc_count(void)
{
return alloc_count;
}
|
int chess_alloc_count(void)
{
return alloc_count;
}
|
void ctss_vm_op_sin_f32(float param_1,long *param_2)
{
long lVar1;
undefined4 extraout_EAX;
lVar1 = *param_2;
sinf(param_1);
*(undefined4 *)(lVar1 + -4) = extraout_EAX;
return;
}
|
void ctss_vm_op_sin_f32(CTSS_VM * vm) {
(*(vm->dsp - 1)).f32 = sinf((*(vm->dsp - 1)).f32);
}
|
void u8g_DrawHBitmap(undefined8 param_1,long param_2,undefined8 param_3,long param_4,
undefined4 *param_5)
{
undefined4 *local_30;
long local_28;
long local_18;
local_30 = param_5;
local_18 = param_2;
for (local_28 = param_4; 0 < local_28; local_28 = local_28 + -1) {
u8g_Draw8Pixel(param_1,local_18,param_3,0,*local_30);
local_30 = local_30 + 1;
local_18 = local_18 + 8;
}
return;
}
|
void u8g_DrawHBitmap(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, const uint8_t *bitmap)
{
while( cnt > 0 )
{
u8g_Draw8Pixel(u8g, x, y, 0, *bitmap);
bitmap++;
cnt--;
x+=8;
}
}
|
int ropSUB_b_rm(undefined8 param_1,undefined8 param_2,undefined4 param_3,int param_4)
{
undefined4 uVar1;
undefined4 uVar2;
undefined8 uVar3;
uint uVar4;
int local_1c;
uVar4 = (uint)param_2;
local_1c = param_4;
if ((uVar4 & 0xc0) == 0xc0) {
uVar2 = LOAD_REG_B(uVar4 & 7);
}
else {
uVar2 = 0;
uVar3 = FETCH_EA(op_ea_seg,param_2,op_ssegs,&local_1c,param_3);
STORE_IMM_ADDR_L(&oldpc,op_old_pc);
MEM_LOAD_ADDR_EA_B(uVar3);
}
uVar1 = LOAD_REG_B((int)uVar4 >> 3 & 7);
STORE_IMM_ADDR_L(0x101054,FLAGS_SUB8);
STORE_HOST_REG_ADDR_BL(0x101050,uVar1);
STORE_HOST_REG_ADDR_BL(0x10104c,uVar2);
SUB_HOST_REG_B(uVar1,uVar2);
STORE_HOST_REG_ADDR_BL(cpu_state,uVar1);
STORE_REG_B_RELEASE(uVar1);
RELEASE_REG(uVar2);
codegen_flags_changed = 1;
return local_1c + 1;
}
|
uint32_t ropSUB_b_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) { int src_reg, dst_reg; if ((fetchdat & 0xc0) == 0xc0) { src_reg = LOAD_REG_B(fetchdat & 7); } else { x86seg *target_seg = FETCH_EA(op_ea_seg, fetchdat, op_ssegs, &op_pc, op_32); STORE_IMM_ADDR_L((uintptr_t)&oldpc, op_old_pc); MEM_LOAD_ADDR_EA_B(target_seg); src_reg = 0; } dst_reg = LOAD_REG_B((fetchdat >> 3) & 7); STORE_IMM_ADDR_L((uint32_t)&cpu_state.flags_op, FLAGS_SUB8); STORE_HOST_REG_ADDR_BL((uint32_t)&cpu_state.flags_op1, dst_reg); STORE_HOST_REG_ADDR_BL((uint32_t)&cpu_state.flags_op2, src_reg); SUB_HOST_REG_B(dst_reg, src_reg); STORE_HOST_REG_ADDR_BL((uint32_t)&cpu_state.flags_res, dst_reg); if (1) STORE_REG_B_RELEASE(dst_reg); else RELEASE_REG(dst_reg); RELEASE_REG(src_reg); codegen_flags_changed = 1; return op_pc + 1; }
|
void sched_interact_update(void)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
piVar4 = (int *)td_get_sched();
iVar2 = *piVar4;
iVar3 = piVar4[1];
iVar1 = iVar2 + iVar3;
if (SCHED_SLP_RUN_MAX <= iVar1) {
if (SCHED_SLP_RUN_MAX * 2 < iVar1) {
if (iVar3 < iVar2) {
*piVar4 = SCHED_SLP_RUN_MAX;
piVar4[1] = 1;
return;
}
piVar4[1] = SCHED_SLP_RUN_MAX;
*piVar4 = 1;
return;
}
if ((SCHED_SLP_RUN_MAX / 5) * 6 < iVar1) {
*piVar4 = iVar2 / 2;
piVar4[1] = iVar3 / 2;
return;
}
*piVar4 = (iVar2 / 5) * 4;
piVar4[1] = (iVar3 / 5) * 4;
}
return;
}
|
void
sched_interact_update(struct thread *td)
{
struct td_sched *ts;
u_int sum;
ts = td_get_sched(td);
sum = ts->ts_runtime + ts->ts_slptime;
if (sum < SCHED_SLP_RUN_MAX)
return;
/*
* This only happens from two places:
* 1) We have added an unusual amount of run time from fork_exit.
* 2) We have added an unusual amount of sleep time from sched_sleep().
*/
if (sum > SCHED_SLP_RUN_MAX * 2) {
if (ts->ts_runtime > ts->ts_slptime) {
ts->ts_runtime = SCHED_SLP_RUN_MAX;
ts->ts_slptime = 1;
} else {
ts->ts_slptime = SCHED_SLP_RUN_MAX;
ts->ts_runtime = 1;
}
return;
}
/*
* If we have exceeded by more than 1/5th then the algorithm below
* will not bring us back into range. Dividing by two here forces
* us into the range of [4/5 * SCHED_INTERACT_MAX, SCHED_INTERACT_MAX]
*/
if (sum > (SCHED_SLP_RUN_MAX / 5) * 6) {
ts->ts_runtime /= 2;
ts->ts_slptime /= 2;
return;
}
ts->ts_runtime = (ts->ts_runtime / 5) * 4;
ts->ts_slptime = (ts->ts_slptime / 5) * 4;
}
|
int pt_pkt_decode_tsc(long param_1,int *param_2)
{
int iVar1;
if ((param_1 == 0) || (param_2 == (int *)0x0)) {
iVar1 = -pte_internal;
}
else {
iVar1 = pt_pkt_read_tsc(param_2 + 2,*(undefined4 *)(param_1 + 4),param_1);
if (-1 < iVar1) {
param_2[1] = ppt_tsc;
*param_2 = iVar1;
}
}
return iVar1;
}
|
int pt_pkt_decode_tsc(struct pt_packet_decoder *decoder,
struct pt_packet *packet)
{
int size;
if (!decoder || !packet)
return -pte_internal;
size = pt_pkt_read_tsc(&packet->payload.tsc, decoder->pos,
&decoder->config);
if (size < 0)
return size;
packet->type = ppt_tsc;
packet->size = (uint8_t) size;
return size;
}
|
void Opdd40(void)
{
ulong uVar1;
byte bVar2;
long lVar3;
lVar3 = *(long *)(reg + (ulong)(inst & 7) * 8);
uVar1 = *(ulong *)(reg + 0x30);
bVar2 = (byte)((ulong)lVar3 >> 0x38);
if ((char)(bVar2 ^ ~(byte)(uVar1 >> 0x38)) < '\0') {
status = status | 2;
}
else {
status = status & 0xfffffffd;
}
if ((status & 0x10) == 0) {
if ((long)~uVar1 < lVar3) {
status = status | 0x11;
}
else {
status = status & 0xffffffee;
}
}
else {
if (lVar3 < (long)~uVar1) {
status = status & 0xffffffee;
}
else {
status = status | 0x11;
}
lVar3 = lVar3 + 1;
}
lVar3 = uVar1 + lVar3;
if (((status & 2) == 0) || (-1 < (char)(bVar2 ^ (byte)((ulong)lVar3 >> 0x38)))) {
status = status & 0xfffffffd;
}
else {
status = status | 2;
}
if ((lVar3 == 0) && ((status & 4) != 0)) {
status = status | 4;
}
else {
status = status & 0xfffffffb;
}
if (lVar3 < 0) {
status = status | 8;
}
else {
status = status & 0xfffffff7;
}
*(long *)(reg + 0x30) = lVar3;
return;
}
|
void Opdd40(void){ register int16 source; register int16 target; register uint16 address2; source = (int16) reg[(inst & 7)]; address2 = 6; target = (int16) reg[address2]; if ((target < 0) == (source < 0)) status |= 0x2U ; else status &= ~0x2U; if ((!!(status&0x10))) { if ((uint32) source >= (uint32) ~target) status |= 0x11U; else status &= ~0x11U; target += source + 1; } else { if ((uint32) source > (uint32) ~target) status |= 0x11U; else status &= ~0x11U; target += source; } if ((!!(status&0x2)) && (target<0) != (source<0)) status |= 0x2U ; else status &= ~0x2U; if (target == 0 ? (!!(status&0x4)) : 0) status |= 0x4U ; else status &= ~0x4U; if (target < 0) status |= 0x8U ; else status &= ~0x8U; *((int16 *) ®[address2]) = target;}
|
void findFactorAndStor(ulong *param_1,long param_2,long param_3)
{
ulong *puVar1;
ulong *puVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
if (param_2 != 0) {
puVar1 = param_1 + param_2;
do {
uVar5 = *param_1;
uVar4 = uVar5;
if (uVar5 <= *(ulong *)(param_3 + 8)) {
uVar4 = *(ulong *)(param_3 + 8);
}
*(ulong *)(param_3 + 8) = uVar4;
if ((uVar5 & 1) == 0) {
uVar4 = uVar5;
if (uVar5 <= *(ulong *)(param_3 + 0x10)) {
uVar4 = *(ulong *)(param_3 + 0x10);
}
*(ulong *)(param_3 + 0x10) = uVar4;
}
if (uVar5 * -0x5555555555555555 < 0x5555555555555556) {
uVar4 = uVar5;
if (uVar5 <= *(ulong *)(param_3 + 0x18)) {
uVar4 = *(ulong *)(param_3 + 0x18);
}
*(ulong *)(param_3 + 0x18) = uVar4;
}
if (3 < uVar5) {
uVar4 = 2;
do {
if (uVar5 % uVar4 == 0) {
uVar3 = uVar5;
if (uVar5 <= *(ulong *)(param_3 + uVar4 * 8)) {
uVar3 = *(ulong *)(param_3 + uVar4 * 8);
}
*(ulong *)(param_3 + uVar4 * 8) = uVar3;
}
uVar4 = uVar4 + 2;
} while (uVar4 * uVar4 < uVar5 || uVar4 * uVar4 - uVar5 == 0);
}
puVar2 = (ulong *)(param_3 + uVar5 * 8);
if (uVar5 <= *puVar2) {
uVar5 = *puVar2;
}
param_1 = param_1 + 1;
*puVar2 = uVar5;
} while (param_1 != puVar1);
}
return;
}
|
void findFactorAndStor(llu *A, llu n, llu *factors, llu factorLimit) {
llu i = 0;
for (i=0;i<n;i++) {
llu j = 1;
llu num = A[i];
if (num % 1 == 0) factors[1] = ((num < factors[1]) ? factors[1] : num);
if (num % 2 == 0) factors[2] = ((num < factors[2]) ? factors[2] : num);
if (num % 3 == 0) factors[3] = ((num < factors[3]) ? factors[3] : num);
for(j=2;j*j<=num;j+=2) {
if (num % j == 0) factors[j] = ((num < factors[j]) ? factors[j] : num);
}
factors[num] = ((num < factors[num]) ? factors[num] : num);
}
}
|
void ADCHardwareOversampleConfigure(int param_1,int param_2)
{
int iVar1;
param_2 = param_2 >> 1;
if (param_2 == 0) {
iVar1 = 0;
}
else {
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
param_2 = param_2 >> 1;
} while (param_2 != 0);
}
*(int *)(long)(param_1 + 0x30) = iVar1;
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;
}
|
void my_Callback_L2P(undefined8 *param_1,undefined8 param_2,ulong param_3,long param_4,int *param_5)
{
ulong local_28;
*param_5 = *param_5 + 1;
for (local_28 = 0; local_28 < param_3; local_28 = local_28 + 1) {
*(int *)(*(long *)(param_5 + 4) + *(long *)(param_4 + local_28 * 8) * 4) =
*(int *)(*(long *)(param_5 + 4) + *(long *)(param_4 + local_28 * 8) * 4) + (int)*param_1;
}
return;
}
|
void my_Callback_L2P(void* cellData, void * leafData, FSize nbParticlesInLeaf, const FSize* particleIndexes, void* userData){
struct MyData* my_data = (struct MyData*)userData;
my_data->countL2P += 1;
struct MyCellDescriptor* my_cell = (struct MyCellDescriptor*) cellData;
;
FSize idxPart;
for(idxPart = 0 ; idxPart < nbParticlesInLeaf ; ++idxPart){
double* position = &my_data->insertedPositions[particleIndexes[idxPart]*3];
my_data->arrayOfInfluence[particleIndexes[idxPart]] += my_cell->dataDown;
;
}
}
|
void load(undefined8 param_1)
{
undefined4 uVar1;
uVar1 = get_type_category(param_1);
switch(uVar1) {
case 0x80:
string_printf(output_buffer,"lduw;");
string_printf(output_buffer,&DAT_0010015e);
break;
case 0x81:
case 0x8b:
string_printf(output_buffer,"ldqw;");
string_printf(output_buffer,&DAT_0010015e);
break;
case 0x82:
case 0x84:
case 0x88:
case 0x8c:
case 0x8d:
case 0x8f:
string_printf(output_buffer,"lddw;");
string_printf(output_buffer,&DAT_0010015e);
break;
case 0x83:
string_printf(output_buffer,"ldub;");
string_printf(output_buffer,&DAT_0010015e);
break;
case 0x89:
case 0x90:
string_printf(output_buffer,&DAT_00100171);
string_printf(output_buffer,&DAT_0010015e);
break;
case 0x8a:
string_printf(output_buffer,&DAT_00100166);
string_printf(output_buffer,&DAT_0010015e);
}
return;
}
|
void load(ExecNode *e)
{
Token cat;
cat = get_type_category(&e->type);
switch (cat) {
case TOK_STRUCT:
case TOK_UNION:
break;
case TOK_FUNCTION:
case TOK_SUBSCRIPT:
break;
case TOK_STAR:
case TOK_LONG:
case TOK_UNSIGNED_LONG:
case TOK_INT:
case TOK_UNSIGNED:
case TOK_ENUM:
(string_printf(output_buffer, "lddw;"), string_printf(output_buffer, "\n"));
break;
case TOK_LONG_LONG:
case TOK_UNSIGNED_LONG_LONG:
(string_printf(output_buffer, "ldqw;"), string_printf(output_buffer, "\n"));
break;
case TOK_SHORT:
(string_printf(output_buffer, "ldw;"), string_printf(output_buffer, "\n"));
break;
case TOK_UNSIGNED_SHORT:
(string_printf(output_buffer, "lduw;"), string_printf(output_buffer, "\n"));
break;
case TOK_CHAR:
case TOK_SIGNED_CHAR:
(string_printf(output_buffer, "ldb;"), string_printf(output_buffer, "\n"));
break;
case TOK_UNSIGNED_CHAR:
(string_printf(output_buffer, "ldub;"), string_printf(output_buffer, "\n"));
break;
}
}
|
void Platform_GetArg(uint param_1,long param_2,long param_3)
{
long lVar1;
long lVar2;
long local_40;
if ((int)param_1 < Platform_ArgCount) {
lVar1 = *Platform_ArgVector;
if (param_1 < 0x400) {
lVar2 = (long)(int)param_1 << 3;
}
else {
Platform_Halt(0xfffffffe);
lVar2 = 0;
}
lVar1 = **(long **)(lVar2 + lVar1);
for (local_40 = 0;
(local_40 < param_3 + -1 &&
(*(char *)(param_2 + local_40) = *(char *)(local_40 + lVar1),
*(char *)(param_2 + local_40) != '\0')); local_40 = local_40 + 1) {
}
*(undefined *)(param_2 + local_40) = 0;
}
return;
}
|
void Platform_GetArg (int n, unsigned char *val, long long val__len)
{
Platform_ArgVec av = ((void*)0);
if (n < Platform_ArgCount) {
av = (Platform_ArgVec)(uintptr_t)Platform_ArgVector;
{char*_a=(void*)*(*av)[(((unsigned long long)(n)<(unsigned long long)(((long long)(1024))))?n:(Platform_Halt(-2),0))],*_b=(void*)val; long long _i=0,_t=val__len-1; while(_i<_t&&((_b[_i]=_a[_i])!=0)){_i++;};_b[_i]=0;};
}
}
|
int sem_getvalue(sem_t *__sem,int *__sval)
{
int *piVar1;
if (__sem->__align == SEM_MAGIC) {
*__sval = *(int *)(__sem->__size + 8);
return 0;
}
piVar1 = __errno_location();
*piVar1 = EINVAL;
return -1;
}
|
int sem_getvalue(sem_t*sem,int*sval) {
if (sem->magic!=SEM_MAGIC) { (*__errno_location())=EINVAL; return -1; }
*sval=sem->value;
return 0;
}
|
bool check_time_sanity(int param_1,int *param_2)
{
bool bVar1;
dt_res._0_8_ = emin_ok;
if ((param_1 == -1) || (0x3c < param_1)) {
dt_res._0_8_ = emin_long;
bVar1 = emin_long == emin_ok;
}
else if (param_1 < 0x3b) {
bVar1 = emin_short == emin_ok;
dt_res._0_8_ = emin_short;
}
else {
bVar1 = true;
}
dt_res._8_4_ = (uint)(*param_2 == 0);
dt_res._12_4_ = (uint)(param_2[0x14] == 1);
dt_res._16_8_ = eDST_ok;
if (param_2[0x11] == param_2[0x12]) {
dt_res._16_8_ = eDST_error;
}
if ((*param_2 == 0 && param_2[0x14] == 1) && (bVar1)) {
return eDST_ok == dt_res._16_8_;
}
return false;
}
|
bool
check_time_sanity(int minlen, const int buffer[])
{
if (minlen == -1 || minlen > 60) {
dt_res.minute_length = emin_long;
} else if (minlen < 59) {
dt_res.minute_length = emin_short;
} else {
dt_res.minute_length = emin_ok;
}
dt_res.bit0_ok = buffer[0] == 0;
dt_res.bit20_ok = buffer[20] == 1;
if (buffer[17] == buffer[18]) {
dt_res.dst_status = eDST_error;
} else {
dt_res.dst_status = eDST_ok;
}
return (dt_res.minute_length == emin_ok) && dt_res.bit0_ok &&
dt_res.bit20_ok && (dt_res.dst_status == eDST_ok);
}
|
void log_kevent_watchtab(undefined8 param_1)
{
char *pcVar1;
pcVar1 = strerror(errno);
report(LOG_ERR,"Unable to queue filter for watchtab \"%s\": %s",param_1,(ulong)pcVar1 & 0xffffffff
);
return;
}
|
void
log_kevent_watchtab(const char *path) {
report(LOG_ERR, "Unable to queue filter for watchtab \"%s\": %s",
path, strerror(errno));
}
|
long * get_tape_right(undefined8 param_1)
{
long lVar1;
undefined4 uVar2;
long lVar3;
long *plVar4;
long lVar5;
lVar3 = get_RP(param_1,1);
plVar4 = (long *)init_expr();
lVar5 = 0;
do {
lVar1 = *plVar4;
uVar2 = get_val_index(param_1,lVar3);
*(undefined4 *)(lVar5 + lVar1) = uVar2;
lVar5 = lVar5 + 4;
lVar3 = lVar3 + 1;
} while (lVar5 != 0x20);
return plVar4;
}
|
ExprTape *get_tape_right(void *self) {
index_t start = get_RP(self, true);
ExprTape *tape = init_expr();
for (int i=0;i<8;i++) tape->tape[i] = get_val_index(self, start + i);
return tape;
}
|
undefined4 get_light_intensity(short param_1)
{
return *(undefined4 *)(lights + (long)param_1 * 4);
}
|
fixed get_light_intensity(
short light_index)
{
return (lights+(light_index))->intensity;
}
|
void err_doit(int param_1,int param_2,char *param_3,__gnuc_va_list param_4)
{
char *pcVar1;
size_t sVar2;
size_t sVar3;
long in_FS_OFFSET;
char acStack_1028 [4104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
vsnprintf(acStack_1028,0xfff,param_3,param_4);
if (param_1 != 0) {
pcVar1 = strerror(param_2);
sVar2 = strlen(acStack_1028);
sVar3 = strlen(acStack_1028);
snprintf(acStack_1028 + (int)sVar3,(ulong)(0xfff - (int)sVar2),": %s",pcVar1);
}
strcat(acStack_1028,"\n");
fflush(stdout);
fputs(acStack_1028,(FILE *)(ulong)stderr);
fflush((FILE *)0x0);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void
err_doit(int errnoflag, int error, const char *fmt, va_list ap)
{
char buf[4096];
vsnprintf(buf, 4096 - 1, fmt, ap);
if (errnoflag)
snprintf(buf + strlen(buf), 4096 - strlen(buf) - 1,
": %s", strerror(error));
strcat(buf, "\n");
fflush(stdout);
fputs(buf, stderr);
fflush(NULL);
}
|
void vc4_crtc_destroy_state(undefined4 *param_1,undefined8 param_2)
{
undefined8 *puVar1;
long *plVar2;
puVar1 = (undefined8 *)to_vc4_dev(*param_1);
plVar2 = (long *)to_vc4_crtc_state(param_2);
if (*plVar2 != 0) {
spin_lock_irqsave(*puVar1,0);
drm_mm_remove_node(plVar2);
spin_unlock_irqrestore(*puVar1,0);
}
drm_atomic_helper_crtc_destroy_state(param_1,param_2);
return;
}
|
void vc4_crtc_destroy_state(struct drm_crtc *crtc,
struct drm_crtc_state *state)
{
struct vc4_dev *vc4 = to_vc4_dev(crtc->dev);
struct vc4_crtc_state *vc4_state = to_vc4_crtc_state(state);
if (vc4_state->mm.allocated) {
unsigned long flags;
spin_lock_irqsave(&vc4->hvs->mm_lock, flags);
drm_mm_remove_node(&vc4_state->mm);
spin_unlock_irqrestore(&vc4->hvs->mm_lock, flags);
}
drm_atomic_helper_crtc_destroy_state(crtc, state);
}
|
void u8g2_Setup_ssd0323_os128064_2
(undefined8 param_1,undefined8 param_2,undefined4 param_3,undefined4 param_4)
{
undefined8 uVar1;
long in_FS_OFFSET;
undefined4 local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
u8x8_Setup(param_1,u8x8_d_ssd0323_os128064,u8x8_cad_001,param_3,param_4);
uVar1 = u8g2_m_16_8_2(&local_24);
u8g2_SetupBuffer(param_1,uVar1,local_24,u8g2_ll_hvline_vertical_top_lsb,param_2);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void u8g2_Setup_ssd0323_os128064_2(u8g2_t *u8g2, const u8g2_cb_t *rotation, u8x8_msg_cb byte_cb, u8x8_msg_cb gpio_and_delay_cb)
{
uint8_t tile_buf_height;
uint8_t *buf;
u8x8_Setup(((u8x8_t *)(u8g2)), (u8x8_d_ssd0323_os128064), (u8x8_cad_001), (byte_cb), (gpio_and_delay_cb));
buf = u8g2_m_16_8_2(&tile_buf_height);
u8g2_SetupBuffer(u8g2, buf, tile_buf_height, u8g2_ll_hvline_vertical_top_lsb, rotation);
}
|
undefined8 ArrayAppend(undefined4 *param_1,undefined8 param_2)
{
undefined8 uVar1;
if (param_1 != (undefined4 *)0x0) {
uVar1 = ArraySet(param_1,*param_1,param_2);
return uVar1;
}
return 0;
}
|
void *ArrayAppend(ARRAY *a, const void *d) {
int i;
if (!a) {
return NULL;
}
i = a->dim;
return ArraySet(a, i, d);
}
|
undefined8 undefined_7023(void)
{
return *(undefined8 *)(functions + 0xdb78);
}
|
void* undefined_7023 () { return (void*)functions[7023].pointer; }
|
double rc_popularity(undefined4 *param_1)
{
int iVar1;
iVar1 = get_param_int(*param_1,"morale",6);
return _LC1 / (double)(iVar1 + -2);
}
|
double rc_popularity(const struct race *rc)
{
int pop = get_param_int(rc->parameters, "morale", 6);
return 1.0 / (pop - 2);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.