- 1
С днём защитника жопы Борманда вас, питухи!
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
0
С днём защитника жопы Борманда вас, питухи!
День защитника Путина.
0
#include <windows.h>
#define PL 7 //длинна пароля
const char F[] = "`1234567890-=\\qwertyuiop[]asdfghjkl;'zxcvbnm,./";
const char N[] = "1`2q1qw32we43er54rt65ty76yu87ui98io09op-0p[=-[]\\=]12wa23esaq34rdsw45tfde56ygfr67uhgt78ijhy89okju90plki0-[;lo-=]';p=\\'[qwszwedxzaerfcxsrtgvcdtyhbvfyujnbguikmnhiol,mjop;.,kp['/.l[]/;asxsdczxdfvcfgbvghnbhjmnjk,mkl.,l;/.;'";
const char L[] = { 1, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 4, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, 3, 4, 4, 4, 4, 4, 4, 4, 4, 3 };
struct _
{
char P[PL + 1];
BYTE I[256], O[48];
};
void __stdcall $(int n, char c, _ *X)
{
X->P[n++] = c;
for (int i = 0; n < PL && i < L[X->I[c]]; $(n, N[X->O[X->I[c]] + i++], X));
for (int i = 0, d = 0, l = 0, s = 0; n == PL && i < n; (X->P[i] >= '0' && X->P[i] <= '9') ? d++ : (X->P[i] >= 'a' && X->P[i] <= 'z') ? l++ : s++, (d && l && s) ? _lwrite(-11, X->P, ++n), i = n : i++);
}
void main()
{
_ w;
w.P[PL] = '\n';
for (int i = 0; i < 47; w.I[F[i]] = i, w.O[i] = i ? w.O[i - 1] + L[i - 1] : 0, i++);
for (int i = 0; i < 47; $(0, F[i++], &w));
}
Генератор сложных (буквы, цифры, символы) паролей с выводом в консоль.
Выводит ВСЕ пароли заданной длинны, которые можно ввести по соседним клавишам без шифта. Всякие лесенки, зигзаги и т.п., т.е. все плохие...
В main переименовал, чтоб скомпилировать. Релизный exe-шник сразу стёр антивирус, сказал Trojan:Win32/Wacatac.B!ml
Обфускаторы рулят :)
−1
void branch(int *cnt, int accum, int nxt, int comn) {
printf("accum %d %d\n", accum, comn);
if (accum < 0 && comn == 41) {
*cnt = nxt;
} else if (accum == 0 && comn == 42) {
*cnt = nxt;
} else if (comn == 40) {
*cnt = nxt;
}
else {
(*cnt)++;
}
}
void dump(int word[]) {
int d = 0, x;
printf("%3c", ' ');
while (d != 10) {
printf("%5d ", d);
d++;
}
for (d = 0; d != MEM; d++) {
x = word[d];
if (0 == (d % 10))
puts(" "), printf("%3d", d);
printf(x >= 0 ? " +%.4X" : " %.4d", x);
}
puts(" ");
}
void dump_file(int word[]) {
int d = 0, x;
FILE *flrun;
flrun = fopen("wrt.txt", "w+");
fprintf(flrun, "%3c", ' ');
while (d != 10) {
fprintf(flrun, "%5d ", d);
d++;
}
for (d = 0; d != MEM; d++) {
x = word[d];
if (0 == (d % 10))
fprintf(flrun, "\n"), fprintf(flrun, "%3d", d);
fprintf(flrun, x >= 0 ? " +%.4X" : " %.4d", x);
}
}
long long_var(long var) {
long step = 1;
do {
step *= 10;
} while (var /= step);
return (step / 10);
}
Демотрон 3
Читалка для кода симплтрона
0
fclose(cfPtr);
while ((mem[operand] > -9999) && (mem[operand] < 9999) && sign != 1) {
ins_rgr = (mem[ins_cnt]);
op_code = (ins_rgr / 100);
operand = (ins_rgr % 100);
// printf("op_code = %d operand = %d acc = %d\n", op_code, operand , acc
// );
// dump(mem);
switch (op_code) {
case HALT:
sign = 1;
break;
case READ:
printf("? read ");
scanf("%d", &buf);
mem[operand] = buf;
ins_cnt++;
break;
case WRITE:
printf("%d\n", mem[operand]);
ins_cnt++;
break;
case LOAD:
acc = mem[operand];
ins_cnt++;
break;
case STORE:
mem[operand] = acc;
ins_cnt++;
break;
case ADD:
acc += mem[operand];
ins_cnt++;
break;
case SUBSTRACT:
acc -= mem[operand];
ins_cnt++;
break;
case DIVIDE:
acc /= mem[operand];
ins_cnt++;
break;
case MUL:
acc *= mem[operand];
ins_cnt++;
break;
case POW:
acc = pow(acc, mem[operand]);
ins_cnt++;
break;
case MOD:
acc = fmod(acc, mem[operand]);
ins_cnt++;
break;
case NEWLINE:
puts(" ");
ins_cnt++;
break;
case BRANCH:
case BRANCHZERO:
case BRANCHNEG:
branch(&ins_cnt, acc, operand, op_code);
break;
}
}
dump(mem);
dump_file(mem);
puts(" ");
}
Демотрон 2
Читалка для кода симплтрона
0
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MEM 100
#define READ 10
#define WRITE 11
#define LOAD 20
#define STORE 21
#define NEWLINE 22
#define ADD 30
#define SUBSTRACT 31
#define DIVIDE 32
#define MUL 33
#define POW 34
#define MOD 35
#define ENTSTR 50
#define PRTSTR 51
#define BRANCH 40
#define BRANCHNEG 41
#define BRANCHZERO 42
#define HALT 43
int main(int argc, char *argv[]) {
void dump_file(int word[]);
FILE *cfPtr;
// char buf[5];
void branch(int *cnt, int accum, int nxt, int comn);
int buf_mem[100] = {0};
void dump(int word[]);
int x = 0, y = 0, s = 0;
// int mem[MEM] = {0};
int mem[MEM];
for (; x != MEM; x++) {
mem[x] = 0;
}
int acc = 0, d = 0;
int ins_cnt = 0, ins_rgr = 0, op_code = 0, operand = 0, buf = 0;
int b = 0, l, r = 0, m = 0, ti = 0, sign = 0;
cfPtr = fopen(argv[1], "r");
for (; feof(cfPtr) == 0;) {
fscanf(cfPtr, "%d %d\n", &b, &l);
mem[b] = l;
}
Демотрон 1
Читалка для кода симплтрона
0
int let_past(data *base, char *infix, char *post_infix) {
char *buffer;
int past_in_table_cons_or_value(data * table, char *str_tok);
int data_adress = 0;
int lng = 0;
int left_side = 0;
past_in_table_cons_or_value(base, &infix[0]);
buffer = strtok(&infix[1], " ");
for (; buffer != (char *)'\0';
post_infix[lng++] = ' ', buffer = strtok(NULL, " ")) {
if (isalnum(*buffer)) {
data_adress = past_in_table_cons_or_value(base, buffer);
sprintf(&post_infix[lng], "%d", data_adress);
lng += 2;
}
else {
post_infix[lng] = *buffer;
lng++;
}
}
post_infix[lng] = '\0';
left_side = search_in_table(base, &infix[0]);
return (base + left_side)->location;
}
int my_strcmp (const char *out, const char *in ){
for( ;*(in) , *(out) && *(in) == *(out); *out++,*in++ );
return *in <= *out ? *out > *in : -1 ;
}
Инклуды длясимплтрона 4
0
int pop_2(StackNodePtr_2 *topPtr) {
StackNodePtr_2 tempPtr;
int popValue;
tempPtr = *topPtr;
popValue = (*topPtr)->data;
*topPtr = (*topPtr)->nextPtr;
free(tempPtr);
return popValue;
}
/* Return the value at the top of the stack */
char stackTop_1(StackNodePtr_2 topPtr) {
char topValue;
topValue = topPtr->data;
return topValue;
}
int isEmpty_2(StackNodePtr_2 topPtr) { return topPtr == NULL; }
/* Test if the list is empty */
int my_isalpha(char alpha) {
return ((alpha >= 65 && alpha <= 90) || (alpha >= 97 && alpha <= 122));
}
int my_isdigit(char alpha) { return (alpha >= 48) && (alpha <= 57); }
int isOperator_2(char c) {
return c == '/' || c == '*' || c == '-' || c == '+' || c == '^' || c == '%';
}
int goto_search(data *table, char *token) {
int x = 0;
for (x = 0; x != 100; x++) {
if (memcmp((table + x)->symbol, token, 2) == 0) {
return (table + x)->location;
}
}
return 0;
}
int helper_search_1(data *base, char *token, int run) {
return ((base + run)->symbol[0] == *token ||
my_strcmp((base + run)->symbol, "0") == 0);
}
int helper_search_2(data *base, char *token, int run) {
return (my_strcmp((base + run)->symbol, token) == 0 ||
my_strcmp((base + run)->symbol, "0") == 0);
}
int search_in_base(data *intro_search, char *str_tok_search) {
int runner = 0, ch = !my_isalpha(*str_tok_search);
for (; !helper_search_base(intro_search, str_tok_search, runner); ++runner)
;
return runner;
}
int helper_search_base(data *base, char *token, int run) {
return my_strcmp((base + run)->symbol, "0") == 0;
}
int search_in_table(data *intro_search, char *str_tok_search) {
int runner = 0, ch = !my_isalpha(*str_tok_search);
for (; !(*helper_search[ch])(intro_search, str_tok_search, runner); ++runner)
;
return runner;
}
int rem_break(char *token) {
if (memcmp(token, "rem", 3) == 0) {
return 1;
}
return 0;
}
Инклуды для симплтрона
0
/* Do the conversion */
while (!isEmpty_2(stackPtr) && infix[i] != '\0') {
c = infix[i++];
if (my_isdigit(c) || my_isalpha(c)) {
while (my_isdigit(c) || my_isalpha(c)) {
postfix[j++] = c;
c = infix[i++];
}
postfix[j++] = ' ';
if (c == ')' || isOperator_2(c))
i--;
} else if (c == '(')
push_2(&stackPtr, '(');
else if (isOperator_2(c) == 1) {
if (!isEmpty_2(stackPtr) && isOperator_2(stackTop_1(stackPtr))) {
while (isOperator_2(stackTop_1(stackPtr)) &&
(precedence_1(stackTop_1(stackPtr), c)) >= 0) {
postfix[j++] = pop_2(&stackPtr);
postfix[j++] = ' ';
}
push_2(&stackPtr, c);
} else
push_2(&stackPtr, c);
} else if (c == ')') {
if (!isEmpty_2(stackPtr)) {
c = pop_2(&stackPtr);
while (!isEmpty_2(stackPtr) && c != '(') {
postfix[j++] = c;
postfix[j++] = ' ';
c = pop_2(&stackPtr);
}
}
}
}
postfix[j] = '\0';
}
int precedence_1(char operator1, char operator2) {
int result = 1;
switch (operator1) {
case '^':
if (operator2 == '^')
result = 0;
break;
case '*':
case '/':
case '%':
switch (operator2) {
case '^':
result = -1;
break;
case '*':
case '/':
case '%':
result = 0;
break;
default:
break;
}
break;
case '+':
case '-':
switch (operator2) {
case '-':
case '+':
result = 0;
break;
default:
result = -1;
break;
}
break;
}
return result;
}
void push_2(StackNodePtr_2 *topPtr, int info) {
StackNodePtr_2 newPtr;
newPtr = malloc(sizeof(StackNode_2)); /* Now points to a place in memory*/
if (newPtr != NULL) {
newPtr->data = info;
newPtr->nextPtr = *topPtr;
*topPtr = newPtr;
} else
printf("%c not inserted. No memory available.\n", info);
}
Инклуды для симплтрона 2
0
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MEM 100
#define READ 10
#define WRITE 11
#define LOAD 20
#define STORE 21
#define ADD 30
#define SUBSTRACT 31
#define DIVIDE 32
#define MUL 33
#define BRANCH 40
#define BRANCHNEG 41
#define BRANCHZERO 42
#define HALT 43
int count_down = 99;
struct stackNode_2 {
int data;
struct stackNode_2 *nextPtr;
};
typedef struct stackNode_2 StackNode_2;
typedef StackNode_2 *StackNodePtr_2;
typedef struct tableEntry {
char symbol[10];
char type;
int location;
} data;
int my_isdigit(char alpha);
int my_isalpha(char alpha);
int isOperator_2(char c);
char stackTop_1(StackNodePtr_2 topPtr);
int helper_search_1(data *base, char *token, int run);
int helper_search_2(data *base, char *token, int run);
int (*helper_search[2])(data *base, char *token, int run) = {helper_search_1,
helper_search_2};
int search_in_base(data *intro_search, char *str_tok_search);
int helper_search_base(data *base, char *token, int run);
void convertToPostfix_1(char infix[], char postfix[]);
int pop_2(StackNodePtr_2 *topPtr);
void push_2(StackNodePtr_2 *topPtr, int info);
int isEmpty_2(StackNodePtr_2 topPtr);
int precedence_1(char operator1, char operator2);
void convertToPostfix_1(char infix[], char postfix[]) {
int i = 0, j = 0;
char c;
/* Push left parenthesis to stack */
StackNodePtr_2 stackPtr = NULL;
push_2(&stackPtr, '(');
/* Add right parenthesis to end of infix */
while (infix[i] != '\0')
i++;
infix[i++] = ')';
infix[i] = '\0';
i = 0;
Инклуды для симплтрона 1
0
int calculate_2(int op1, int op2, char operator, int memory_smp[],
int *count_command) {
int result = 0;
switch (operator) {
case '+':
memory_smp[*count_command] = (2000 + op1);
(*count_command)++;
memory_smp[*count_command] = (3000 + op2);
(*count_command)++;
memory_smp[*count_command] = (2100 + count_down);
(*count_command)++;
result = count_down;
count_down--;
// result = op1 + op2;
break;
case '-':
memory_smp[*count_command] = (2000 + op1);
(*count_command)++;
memory_smp[*count_command] = (3100 + op2);
(*count_command)++;
memory_smp[*count_command] = (2100 + count_down);
(*count_command)++;
result = count_down;
count_down--;
// result = op1 - op2;
break;
case '*':
memory_smp[*count_command] = (2000 + op1);
(*count_command)++;
memory_smp[*count_command] = (3300 + op2);
(*count_command)++;
memory_smp[*count_command] = (2100 + count_down);
(*count_command)++;
result = count_down;
count_down--;
// result = op1 * op2;
break;
case '/':
memory_smp[*count_command] = (2000 + op1);
(*count_command)++;
memory_smp[*count_command] = (3200 + op2);
(*count_command)++;
memory_smp[*count_command] = (2100 + count_down);
(*count_command)++;
result = count_down;
count_down--;
// result = op1 / op2;
break;
/*
case '^':
result = pow(op1, op2);
break;
case '%':
result = op1 % op2;
break;
*/
default:
break;
}
return result;
}
Симлтрон из Дейтелов
5