try-cat.ch hard 갇혔어요!

크리에이티브 커먼즈 라이선스
Creative Commons License

이 문제는 직접 주변값들을 확인해 정석적으로 풀려면 힘들겠지만

조건이 매우 단순해 단순한 조건문으로 풀었다

로컬에서는 행렬을 한번에 다붙여넣는거라 생각해서 코드를 작성했었는데

try-cat.ch에서 테스트할땐 한줄씩 넣길래

코드를 고치기 귀찮아서 약간의 편법을 썼다


m,n = [int(x) for x in raw_input().split(" ")]
raw = ''.join([raw_input()+"\n" for x in range(m)])
a = raw.split("\n")[:-1]
for i in range(len(a)):
    a[i] = a[i].split(" ")
    if a[i][-1] is '':
        a[i] = a[i][:-1]
ans = []
for i in range(0, m):
    for j in range(0, n):
        if i is not 0 and \
            i is not m-1 and \
            j is not 0 and \
            j is not n-1:
                if a[i][j] == '1':
                    print str(i+1)+","+str(j+1)
신고

'컴퓨터공부 > 프로그래밍' 카테고리의 다른 글

try-cat.ch hard 갇혔어요!  (0) 2015.06.05
try-cat.ch hard 큰 숫자로 합치기  (0) 2015.06.05
try-cat.ch hard 연속된 숫자 찾기  (0) 2015.06.05
assert 함수 동작 원리  (0) 2015.05.09
가상화 5월 5일버젼  (1) 2014.05.05
vm설계할때 노트한내용  (0) 2014.03.26

설정

트랙백

댓글

try-cat.ch hard 큰 숫자로 합치기

크리에이티브 커먼즈 라이선스
Creative Commons License

45 456

과 같이 두개의 자연수가 합쳐지고

숫자열을 재조합해 가장큰 자연수를 만드는 문제다

45 456 입력에 대한 출력예시는 65544이다


num = sorted(''.join([x for x in raw_input("").split(" ")]))[::-1]

print ''.join(num)

신고

'컴퓨터공부 > 프로그래밍' 카테고리의 다른 글

try-cat.ch hard 갇혔어요!  (0) 2015.06.05
try-cat.ch hard 큰 숫자로 합치기  (0) 2015.06.05
try-cat.ch hard 연속된 숫자 찾기  (0) 2015.06.05
assert 함수 동작 원리  (0) 2015.05.09
가상화 5월 5일버젼  (1) 2014.05.05
vm설계할때 노트한내용  (0) 2014.03.26

설정

트랙백

댓글

try-cat.ch hard 연속된 숫자 찾기

크리에이티브 커먼즈 라이선스
Creative Commons License
연속된 숫자 찾기
Btn_try
배열에서 가장 긴 연속된 숫자열을 구한다.

정수의 배열이 입력으로 주어졌을 때, 연속된 숫자들로 이루어진 가장 긴 

부분배열을 찾아라

Time Limit : 200ms, Memory Limit : 512kb
10개 미만의 임의의 자연수로 이루어진 배열
입력 샘플

4 5 34 33 32 11 10 31

자연수 배열
출력 샘플

31 32 33 34


ans = []
max = (0, 0)
data = sorted([int(x) for x in raw_input().split(" ")])
cur = 0
i=0
while True:
    if i+cur+1 > len(data)-1:
        break
    while 1:
        if i+cur+1 < len(data) and data[i+cur]+1 == data[i+cur+1]:
            cur += 1
        else:
            break
    if cur:
        ans.append(data[i:i+cur+1])
        if max[0] < cur:
            max = (cur+1, data[i:i+cur+1])
        i += cur-1
    cur = 0
    i += 1
ans = ''.join([str(x)+" " for x in max[1]])
print ans


신고

'컴퓨터공부 > 프로그래밍' 카테고리의 다른 글

try-cat.ch hard 갇혔어요!  (0) 2015.06.05
try-cat.ch hard 큰 숫자로 합치기  (0) 2015.06.05
try-cat.ch hard 연속된 숫자 찾기  (0) 2015.06.05
assert 함수 동작 원리  (0) 2015.05.09
가상화 5월 5일버젼  (1) 2014.05.05
vm설계할때 노트한내용  (0) 2014.03.26

설정

트랙백

댓글

assert 함수 동작 원리

크리에이티브 커먼즈 라이선스
Creative Commons License

assert함수에서 에러메세지를 출력할때 안의 조건문을 출력해주길래

어떤식으로 정보들을 출력하는지 궁금했다


root@LeaveRet_server:/cd80# cat test.c

#include <assert.h>

main(){

int i=10;

assert(i==9);

}

root@LeaveRet_server:/cd80#

위와 같은 코드를 컴파일하고 실행하면

root@LeaveRet_server:/cd80# ./test

test: test.c:4: main: Assertion `i==9' failed.

Aborted (core dumped)

root@LeaveRet_server:/cd80# 

이런 출력이 나온다


디스어셈블 해보면

i = 10;

if(i==9) { goto locret_8048459; }

else{ __assert_fail(assertion, file, line, func); }

이런 형태가 보인다

assert가 __assert_fail로 바껴서 컴파일이 됐는데

glibc-2.19/assert/assert.h를 보면



# define assert(expr) \

  ((expr) \

   ? __ASSERT_VOID_CAST (0) \

   : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION))

 

assert는 이렇게 돼있다

이건 위에서 쓴 

if(i==9) { goto locret_8048459; }

else{ __assert_fail(assertion, file, line, func); }

이 if 문과 else문이 다 설명이 되는 코드인데

우선 expr의 결과가 참인지 거짓인지 판별하고 참이라면 assert(expr)의 결과는 void이다

참고↓

#if defined __cplusplus && __GNUC_PREREQ (2,95)

# define __ASSERT_VOID_CAST static_cast<void>

#else

# define __ASSERT_VOID_CAST (void)

#endif 


expr이 만약 거짓이라면 __assert_fail(__STRING(expr), __FILE__, __LINE, __ASSERT_FUNCTION)) 을 호출하는데

__STRING은 glibc-2.19/misc/sys/cdefs.h 에 정의돼있다

#define __STRING(x) #x

이건 그냥 안에 있는 글자들을 문자열로 그대로 바꾸는 역할을한다

__STRING(cd80) 이라고 하면 "cd80" 이 리턴되는것이다

이건 다른 코드를 작성할때도 매우 유용하게 쓰이는 매크로 중 하나다

그러면 assert(i==9) 라고 했을때 어떻게 "i==9" 라는 문자열이 출력됐는지는 명확해진다

__STRING(i==9) 로 전달돼서 "i==9"로 바뀐것이다

나머지는 그냥 printf("%s %s %d\n", __FILE__, __ASSERT_FUNCTION__, __LINE); 해보면 알수있다



신고

'컴퓨터공부 > 프로그래밍' 카테고리의 다른 글

try-cat.ch hard 큰 숫자로 합치기  (0) 2015.06.05
try-cat.ch hard 연속된 숫자 찾기  (0) 2015.06.05
assert 함수 동작 원리  (0) 2015.05.09
가상화 5월 5일버젼  (1) 2014.05.05
vm설계할때 노트한내용  (0) 2014.03.26
가상화 구현  (0) 2014.03.26

설정

트랙백

댓글

가상화 5월 5일버젼

크리에이티브 커먼즈 라이선스
Creative Commons License

cpu.c


#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "virtual.h"

char string[] = "Hello, World!\n";

main(){

VRegister *VCPU = malloc(sizeof(VRegister));

void (*INSTRUCTION_HANDLERS[256])(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION *cur;

PVOID operands = malloc(8);

PVOID vmcode = malloc(4096);

PVOID vmdata = malloc(4096);

PVOID stack = malloc(4096);

unsigned short instruction_count=0;

initialize_instruction_table(INSTRUCTION_HANDLERS);


memcpy(vmcode, "\x00\x40\x05\x04\x00\x00\x00\x00"

"\x00\x40\x05\x01\x00\x00\x00\x01"

"\x00\x40\x05\x34\xa0\x04\x08\x02"

"\x00\x40\x05\x0f\x00\x00\x00\x03"

"\x08\x88\x01\x80"

"\x00\x40\x05\x01\x00\x00\x00\x00"

"\x08\x88\x01\x80",

48);

VCPU -> eax = 0;

VCPU -> ebx = 0;

VCPU -> ecx = 0;

VCPU -> edx = 0;

VCPU -> esi = 0;

VCPU -> edi = 0;

VCPU -> ebp = stack;

VCPU -> esp = stack;

VCPU -> eip = vmcode;

VCPU -> REGISTER_COUNT = 0;

PPDWORD REGISTER_TABLE[] = {&VCPU->eax, &VCPU->ebx, &VCPU->ecx, &VCPU->edx,

&VCPU->esi, &VCPU->edi, &VCPU->ebp, &VCPU->esp, &VCPU->eip, 0};

VCPU -> REGISTER = REGISTER_TABLE;

while(VCPU->REGISTER[VCPU->REGISTER_COUNT++]);

while(INSTRUCTION_HANDLERS[instruction_count++]);


while(1){

bzero(operands, 8);

cur = VCPU->eip;

if(cur->opcode > instruction_count){

printf("Invalid opcode: %x\n", cur->opcode);

exit(0);

}

memcpy(operands, cur->operands, cur->length);

INSTRUCTION_HANDLERS[cur->opcode](operands, cur->type, VCPU);

VCPU->eip += (cur->length + 3)/4; // operand length + 3(opcode, type, length);

}

}



virtual.c


#include <stdio.h>

#include <string.h>

#include "virtual.h"


void initialize_instruction_table(void (*instruction_table[256])(PVOID operands, BYTE type, VRegister *VCPU)){

instruction_table[0] = mov;

instruction_table[1] = dummy;

instruction_table[2] = dummy;

instruction_table[3] = dummy;

instruction_table[4] = dummy;

instruction_table[5] = dummy;

instruction_table[6] = dummy;

instruction_table[7] = dummy;

instruction_table[8] = interrupt;

instruction_table[9] = 0;

}

INSTRUCTION_HANDLER dummy(PVOID operands, BYTE type, VRegister *VCPU){

puts("Not implemented yet");

}

INSTRUCTION_HANDLER mov(PVOID operands, BYTE type, VRegister *VCPU){

unsigned long *op1;

unsigned long *op2;

BYTE type_op1;

BYTE type_op2;

PDWORD memderef;

op1 = operands;

op2 = operands + 4;


type_op1 = type>>4<<4;

type_op2 = ((type<<4)&0xff)>>4;


switch(type_op1){

case OP1_DATA:

switch(type_op2){

case OP2_REGISTER:

if(*op2 & REGISTER_POINTER || *op2 < 0 || *op2 > VCPU->REGISTER_COUNT){ 

printf("Invalid operand\n"); 

exit(-1);

}

*VCPU->REGISTER[*op2] = *op1;

break;

case OP2_PREGISTER:

if(!*op2 & REGISTER_POINTER || *op2 < 0 || *op2 > VCPU->REGISTER_COUNT){ 

printf("Invalid operand\n"); 

exit(-1);

}

memderef = *VCPU->REGISTER[*op2 & 0x0000000f];

*memderef = *op1;

break;

case OP2_PMEMORY:

memderef = *op2;

*memderef = *op1;

break;

default:

printf("Invalid operand\n");

exit(-1);

}

break;

case OP1_REGISTER:

switch(type_op2){

case OP2_REGISTER: // mov reg, reg

*VCPU->REGISTER[*op2] = *VCPU->REGISTER[*op1];

break;

}

break;

}

}

INSTRUCTION_HANDLER interrupt(PVOID operands, BYTE type, VRegister *VCPU){

asm(

"mov %0, %%eax\n\t"

"mov %3, %%ebx\n\t"

"mov %2, %%ecx\n\t"

"mov %1, %%edx\n\t"

"mov %4, %%esi\n\t"

"mov %5, %%edi\n\t"

"int $0x80"

:

: "m"(VCPU->eax), "m"(VCPU->edx), "m"(VCPU->ecx), "m"(VCPU->ebx), 

"m"(VCPU->esi), "m"(VCPU->edi)

);


asm(

"mov %%eax, %0\n\t"

"mov %%ebx, %3\n\t"

"mov %%ecx, %2\n\t"

"mov %%edx, %1\n\t"

"mov %%esi, %4\n\t"

"mov %%edi, %5\n\t"

: "=m"(VCPU->eax), "=m"(VCPU->edx), "=m"(VCPU->ecx), "=m"(VCPU->eax),

"=m"(VCPU->esi), "=m"(VCPU->edi)

);

}



virtual.h


#ifndef __VIRTUAL_H__

#define __VIRTUAL_H__


#define OP1_REGISTER 0x00

#define OP1_PREGISTER 0x10

#define OP1_PMEMORY 0x20

#define OP1_DATA 0x40

#define OP1_SINGLE 0x80


#define OP2_REGISTER 0x00

#define OP2_PREGISTER 0x01

#define OP2_PMEMORY 0x02

#define OP2_DATA 0x04

#define OP2_SINGLE 0x08


#define REGISTER_EAX 0x00

#define REGISTER_EBX 0x01

#define REGISTER_ECX 0x02

#define REGISTER_EDX 0x03

#define REGISTER_ESI 0x04

#define REGISTER_EDI 0x05

#define REGISTER_EBP 0x06

#define REGISTER_ESP 0x07

#define REGISTER_EIP 0x08

#define REGISTER_POINTER 0x10


typedef unsigned long DWORD;

typedef unsigned long* PDWORD;

typedef unsigned long** PPDWORD;

typedef unsigned char BYTE;

typedef char* PCHAR;

typedef void* PVOID;

typedef void INSTRUCTION_HANDLER;


typedef struct Register_List{

PDWORD eax;

PDWORD ebx;

PDWORD ecx;

PDWORD edx;

PDWORD esi;

PDWORD edi;

PDWORD ebp;

PDWORD esp;

PDWORD eip;

PPDWORD REGISTER;

BYTE REGISTER_COUNT;

} VRegister;


typedef struct INSTRUCTION_STRUCT{

BYTE opcode;

BYTE type;

BYTE length;

char operands[8]; // max operand length = 8

} INSTRUCTION;


INSTRUCTION_HANDLER dummy(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER mov(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER lea(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER add(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER sub(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER jmp(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER call(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER push(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER pop(PVOID operands, BYTE type, VRegister *VCPU);

INSTRUCTION_HANDLER interrupt(PVOID operands, BYTE type, VRegister *VCPU);

#endif


신고

'컴퓨터공부 > 프로그래밍' 카테고리의 다른 글

try-cat.ch hard 큰 숫자로 합치기  (0) 2015.06.05
try-cat.ch hard 연속된 숫자 찾기  (0) 2015.06.05
assert 함수 동작 원리  (0) 2015.05.09
가상화 5월 5일버젼  (1) 2014.05.05
vm설계할때 노트한내용  (0) 2014.03.26
가상화 구현  (0) 2014.03.26

설정

트랙백

댓글

vm설계할때 노트한내용

크리에이티브 커먼즈 라이선스
Creative Commons License

AT&T

instructions to virtualize
mov
lea
add
jmp
call
push
pop
int


virtual cpu
virtual register
virtual stack
virtual code
virtual data

instruction 구조
[opcode(00~ff)] opinfo[operand type || operand length](2byte) [ operands ]

0 : register len:1
1 : (register) len:1
2 : (memory) len:4
4 : data len:4
88 : single len:depends on data

opinfo
operand type example
 02 mov register, (memory)
 40 mov data, register
 41 mov data, (register)
 20 mov (memory), register
operand length
 01 ~ 08

register:
 eax 00
 ebx 01
 ecx 02
 edx 03
 esi 04
 edi 05
 ebp 06
 esp 07
 eip 08

opcode list

mov 00
lea 01
add 02
jmp 03
call 04
push 05
pop 06
int 07

eax = 0x12345678
mov(1234, &eax);

INSTRUCTION_HANDLERS[cur->opcode](cur->operands, cur->type);

 

 

 

 

sample vm

mov $0x4, %eax
mov $0x1, %ebx
mov $string, %ecx
mov len(String), %edx
int $0x80


mov $0x4, %eax -> 0040050400000000
mov $0x1, %ebx -> 0040050100000001
mov $string, %ecx -> 004005aaaaaaaa02
mov $0xf, %edx -> 0040050f00000003
int $0x80 -> 08880180


char data[] = "Hello, World!\n";

0040050400000000
0040050100000001
004005aaaaaaaa02
0040050f00000003
08880180
0040050100000000
08880180

신고

'컴퓨터공부 > 프로그래밍' 카테고리의 다른 글

try-cat.ch hard 큰 숫자로 합치기  (0) 2015.06.05
try-cat.ch hard 연속된 숫자 찾기  (0) 2015.06.05
assert 함수 동작 원리  (0) 2015.05.09
가상화 5월 5일버젼  (1) 2014.05.05
vm설계할때 노트한내용  (0) 2014.03.26
가상화 구현  (0) 2014.03.26

설정

트랙백

댓글

가상화 구현

크리에이티브 커먼즈 라이선스
Creative Commons License

가상화가 적용돼있는 대회문제를 풀면서 한번 직접 구현해보고 싶어서 제작해봤습니다

일단 코드 실행이 가능한지 여부를 알고 싶어서 mov랑 int만을 이용해

mov $4, %eax

mov $1, %ebx

mov $string, %ecx

mov $15, %edx

int $0x80

이 명령들을 가상화해봤습니다

 

 

 

소스코드는 main.c virtual.c virtual.h 세개입니다

 

컴파일할때 virtual.c의 interrupt() 인라인어셈부분이 원하는대로 되지 않기때문에

gcc -S virtual.c 로 virtual.s 파일을 만드셔서

virtual.s 에서 int $0x80 위의 세줄을 수정하시면 됩니다

main.c

 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "virtual.h"
char string[] = "Hello, World!\n";
main(){
 VRegister *VCPU = malloc(sizeof(VRegister));
 void (*INSTRUCTION_HANDLERS[256])(PVOID operands, BYTE type, VRegister *VCPU);
 INSTRUCTION *cur;
 PVOID operands = malloc(8);
 PVOID vmcode = malloc(4096);
 PVOID vmdata = malloc(4096);
 PVOID stack = malloc(4096);
 unsigned short instruction_count=0;
 initialize_instruction_table(INSTRUCTION_HANDLERS);

 memcpy(vmcode, "\x00\x40\x05\x04\x00\x00\x00\x00"    // mov $4, %eax
   "\x00\x40\x05\x01\x00\x00\x00\x01"    // mov $1, %ebx
   "\x00\x40\x05\x34\xa0\x04\x08\x02"   // mov $string, %ecx
   "\x00\x40\x05\x0f\x00\x00\x00\x03"    // mov $15, %edx
   "\x08\x88\x01\x80"    // int $0x80 { write(1, "Hello, World!\n", 15); }
   "\x00\x40\x05\x01\x00\x00\x00\x00"    // mov $1, %eax
   "\x08\x88\x01\x80",    // int $0x80 { exit(1); }
  48);
 
 VCPU -> eax = 0;
 VCPU -> ebx = 0;
 VCPU -> ecx = 0;
 VCPU -> edx = 0;
 VCPU -> esi = 0;
 VCPU -> edi = 0;
 VCPU -> ebp = stack;
 VCPU -> esp = stack;
 VCPU -> eip = vmcode;

 while(INSTRUCTION_HANDLERS[instruction_count++]);

 while(1){
  bzero(operands, 8);
  cur = VCPU->eip;
  if(cur->opcode > instruction_count){
   printf("Invalid opcode: %x\n", cur->opcode);
   exit(0);
  }
  memcpy(operands, cur->operands, cur->length);
  INSTRUCTION_HANDLERS[cur->opcode](operands, cur->type, VCPU);
  VCPU->eip += (cur->length + 3); // operand length + 3(opcode, type, length);
 }
}

 

 virtual.c

 #include <stdio.h>
#include <string.h>
#include "virtual.h"

//void (*INSTRUCTION_HANDLERS[256])(PVOID operands, BYTE type, VRegister *VCPU);
//INSTRUCTION_HANDLERS = {mov, lea, add, sub, jmp, call, push, pop, interrupt, 0};
void initialize_instruction_table(void (*instruction_table[256])(PVOID operands, BYTE type, VRegister *VCPU)){
 instruction_table[0] = mov;
 instruction_table[1] = dummy;
 instruction_table[2] = dummy;
 instruction_table[3] = dummy;
 instruction_table[4] = dummy;
 instruction_table[5] = dummy;
 instruction_table[6] = dummy;
 instruction_table[7] = dummy;
 instruction_table[8] = interrupt;
 instruction_table[9] = 0;
}
INSTRUCTION_HANDLER dummy(PVOID operands, BYTE type, VRegister *VCPU){
 puts("Not implemented yet");
}
INSTRUCTION_HANDLER mov(PVOID operands, BYTE type, VRegister *VCPU){
 unsigned long *op1;
 unsigned long *op2;
 switch(type){
  case OP1_DATA | OP2_REGISTER:
   op1 = operands;
   op2 = operands+4;
   switch(*op2){
    case '\x00':
     VCPU->eax = *op1;
     break;
    case '\x01':
     VCPU->ebx = *op1;
     break;
    case '\x02':
     VCPU->ecx = *op1;
     break;
    case '\x03':
     VCPU->edx = *op1;
     break;
     
   }
   break;
    
 }
}
INSTRUCTION_HANDLER interrupt(PVOID operands, BYTE type, VRegister *VCPU){
 asm(
  "mov %0, %%eax\n\t"
  "mov %1, %%ebx\n\t"
  "mov %2, %%ecx\n\t"
  "mov %3, %%edx\n\t"
  "int $0x80"
  :
  : "m"(VCPU->eax), "m"(VCPU->ebx), "m"(VCPU->ecx), "m"(VCPU->edx)
 );
}

 

 

virtual.h

 

 #ifndef __VIRTUAL_H__
#define __VIRTUAL_H__

#define OP1_REGISTER 0x00
#define OP1_PREGISTER 0x10
#define OP1_PMEMORY 0x20
#define OP1_DATA 0x40
#define OP1_SINGLE 0x80

#define OP2_REGISTER 0x00
#define OP2_PREGISTER 0x01
#define OP2_PMEMORY 0x02
#define OP2_DATA 0x04
#define OP2_SINGLE 0x08


typedef unsigned long DWORD;
typedef unsigned long* PDWORD;
typedef unsigned char BYTE;
typedef char* PCHAR;
typedef void* PVOID;

typedef void INSTRUCTION_HANDLER;

typedef struct Register_List{
 DWORD eax;
 DWORD ebx;
 DWORD ecx;
 DWORD edx;
 DWORD esi;
 DWORD edi;
 DWORD ebp;
 DWORD esp;
 PVOID eip;
} VRegister;

typedef struct INSTRUCTION_STRUCT{
 BYTE opcode;
 BYTE type;
 BYTE length;
 char operands[8]; // max operand length = 8
} INSTRUCTION;

INSTRUCTION_HANDLER dummy(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER mov(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER lea(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER add(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER sub(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER jmp(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER call(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER push(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER pop(PVOID operands, BYTE type, VRegister *VCPU);
INSTRUCTION_HANDLER interrupt(PVOID operands, BYTE type, VRegister *VCPU);

//void (*INSTRUCTION_HANDLERS[256])(PVOID operands, BYTE type, VRegister *VCPU);
#endif

 

신고

'컴퓨터공부 > 프로그래밍' 카테고리의 다른 글

try-cat.ch hard 큰 숫자로 합치기  (0) 2015.06.05
try-cat.ch hard 연속된 숫자 찾기  (0) 2015.06.05
assert 함수 동작 원리  (0) 2015.05.09
가상화 5월 5일버젼  (1) 2014.05.05
vm설계할때 노트한내용  (0) 2014.03.26
가상화 구현  (0) 2014.03.26

설정

트랙백

댓글


티스토리 툴바