이번 강좌에서는
에 대해서 배웁니다.
안녕하세요 여러분! 지난번 강좌는 재미있으셨나요. C++ 이란 산을 넘기 위해 아직도 지나가야 할 관문이 앞에 수 없이 많지만, 그래도 이번 강좌를 통해서 그 관문 하나는 지나갈 수 있으리라 생각합니다. 이번 강좌에서는 객체지향프로그래밍의 핵심 개념 하나에 대해서 배울 것입니다. 기대하세요 :)
일단 이야기를 진행하기 전에, 어떠한 경우에서 상속을 사용하는지 생각해봅시다. C++ 에서 상속을 도입한 이유는 단순히 똑같은 코드를 또 쓰는 것을 막기 위한 Ctrl + C, Ctrl + V 방지용으로 위한 것이 아닙니다 (물론 그러한 이유도 약간 있겠지만). 실제 이유는 상속이라는 기능을 통해서 객체지향프로그래밍에서 추구하는 실제 객체의 추상화를 좀 더 효과적으로 할 수 있게 되었습니다.
이게 무슨 말이냐면 상속이란 것이 없던 C 언어에서는 어떠한 구조체 사이의 관계를 표현할 수 있는 방법이 없었습니다. 하지만 C++ 에서 상속이란 것을 도입함으로써, 클래스 사이에 관계를 표현할 수 있게 되었는데, 예를 들어서 Manager
가 Employee
를 상속한다;
class Manager : public Employee
의 의미는,
Manager
클래스는 Employee
의 모든 기능을 포함한다
Manager
클래스는 Employee
의 기능을 모두 수행할 수 있기 때문에 (Manager 에게는 약간 기분 나쁘겠지만) Manager
를 Employee
라고 칭해도 무방하다
즉, 모든 Manager
는 Employee
이다
Manager is a Employee !!
따라서, 모든 상속 관계는 is a 관계라고 볼 수 있습니다. 당연한 점은, 이를 뒤바꾸면 성립되지 않는 다는 점입니다. 즉 Manager
는 Employee
이지만 Employee
는 Manager
가 아닙니다. 이렇기에, Manager
를 Employee
로 부를 수 있지만, Employee
는 Manager
로 (미안하게도) 부를 수 없습니다.
프로그램 설계 시에 클래스들 간의 상속 관계를 도표로 나타내는 경우가 종종 있는데, 많은 경우 파생 클래스가 기반 클래스를 화살표로 가리키게 그립니다.
실제 세상에서 is a
관계로 이루어진 것들은 수 없이 많습니다. 예를 들어, '사람' 이라는 클래스가 있다면, '프로그래머는 사람이다 (A programmer is a human)' 이므로, 만일 우리가 프로그래머 클래스를 만든다면 사람 이라는 클래스를 상속 받을 수 있도록 구성할 수 있습니다.
위는 또 다른 is - a
관계의 예로, BankAccount
(은행 계좌) 라는 클래스가 있고 Checking Account
(자유롭게 입출금이 가능한 계좌지만 이자가 없다) 와 Savings Account
(비교적 자유롭게 입출금이 불가능하지만, 매 달 이자가 붙음) 가 이를 상속 받고 있습니다. 즉, 같은 계좌지만 기능이 약간 씩 다른 두 계좌 클래스들이 좀 더 '일반적인' BankAccount
클래스를 상속 받았지요.
이를 통해서 상속의 또 하나의 중요한 특징을 알 수 있습니다. 바로 클래스가 파생되면 파생될 수 록 좀 더 특수화 (구체화;specialize) 된다는 의미 입니다. 즉, Employee
클래스가 일반적인 사원을 위한 클래스 였다면 Manager
클래스 들은 그 일반적인 사원들 중에서도 좀 더 특수한 부류의 사원들을 의미하게 됩니다.
또, BankAccount
도 일반적인 은행 계좌를 위한 클래스 였다면, 이를 상속 받는 CheckingAccount, SavingsAccount
들은 좀 더 구체적인 클래스가 되지요. 반대로, 기반 클래스로 거슬러 올라가면 올라갈 수 록 좀 더 일반화 (generalize) 된다고 말합니다.
그렇다면 모든 클래스들의 관계를 is - a
로만 표현할 수 있을까요? 당연히 그렇지 않습니다. 어떤 클래스들 사이에서는 is - a
대신에 has - a
관계가 성립하기도 합니다. 예를 들어서, 간단히 자동차 클래스를 생각해봅시다. 자동차 클래스를 구성하기 위해서는 엔진 클래스, 브레이크 클래스, 오디오 클래스 등 수 많은 클래스들이 필요합니다. 그렇다고 이들 사이에 is a
관계를 도입 할 수 없습니다. (자동차 is a
엔진? 자동차 is a
브레이크?) 그 대신, 이들 사이는 has - a
관계로 쉽게 표현할 수 있습니다.
즉, 자동차는 엔진을 가진다 (자동차 has a
엔진), 자동차는 브레이크를 가진다 (자동차 has a
브레이크) 이와 같이 말이지요. 이런 has - a
관계는 우리가 흔히 해왔듯이 다음과 같이 클래스로 나타내면 됩니다.
class Car {
private:
Engine e;
Brake b; // 아마 break 아니냐고 생각하는 사람들이 있을 텐데 :)
....
};
또 다른 예로 바로 우리의 EmployeeList
를 들을 수 도 있습니다. EmployeeList
는 Employee
들과 has - a
관계 이지요. 따라서, 실제로 EmployeeList
클래스를 보면
class EmployeeList {
int alloc_employee; // 할당한 총 직원 수
int current_employee; // 현재 직원 수
Employee ** employee_list; // 직원 데이터
와 같이 Employee
를 포함하고 있음을 알 수 있습니다.
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : s ( "파생" ), Base () { std :: cout << "파생 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
int main () {
std :: cout << " === 기반 클래스 생성 ===" << std :: endl;
Base p;
p . what ();
std :: cout << " === 파생 클래스 생성 ===" << std :: endl;
Derived c;
c . what ();
return 0 ;
}
성공적으로 컴파일 하였다면
실행 결과
=== 기반 클래스 생성 ===
기반 클래스
기반
=== 파생 클래스 생성 ===
기반 클래스
파생 클래스
파생
이미 저번 강좌에서도 이야기 했었지만, Base
에서 what
을 호출하면 당연히 Base
의 what
이 실행되어서 '기반' 라고 나오고, Base
를 상속받는 Derived
클래스에서 what
을 호출하면, Derived
의 what
이 Base
의 what
을 오버라이드 해서 Derived
의 what
이 호출되게 됩니다.
이번에는 코드를 약간 변형해보도록 하겠습니다.
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : s ( "파생" ), Base () { std :: cout << "파생 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
int main () {
Base p;
Derived c;
std :: cout << "=== 포인터 버전 ===" << std :: endl;
Base * p_c = & c;
p_c -> what ();
return 0 ;
}
성공적으로 컴파일 하였다면
실행 결과
기반 클래스
기반 클래스
파생 클래스
=== 포인터 버전 ===
기반
이번에는 Derived
의 객체 c
를 Base
객체를 가리키는 포인터에 넣었습니다.
Base * p_c = & c;
어떤 분들은 이와 같은 대입이 가능하냐고 물을 수 있습니다. Base
와 Derived
는 다른 클래스 이니까요. 하지만, 그 분들이 간과하고 있는 점은 Derived
가 Base
를 상속 받고 있다는 점입니다. 상속 받는다면 뭐죠? Derived is a Base
즉 (말이 조금 이상하지만) Derived
객체 c
도 어떻게 보면 Base
객체이기 때문에 Base
객체를 가리키는 포인터가 c
를 가리켜도 무방하다는 것입니다. 이를 그림으로 표현한다면 아래와 같습니다.
그 대신 p
는 엄연한 Base
객체를 가리키는 포인터 입니다. 따라서, p
의 what
을 실행한다면 p
는 당연히 '아 Base
의 what
을 실행해 주어야 겠구나' 하고, Base
의 what
을 실행해서, Base
의 what
은 Base
의 s
를 출력 하게 됩니다. 따라서 위 처럼 '기반' 가 출력됩니다.
이러한 형태의 캐스팅을 (즉 파생 클래스에서 기반 클래스로 캐스팅 하는 것) 을 업 캐스팅 이라고 부릅니다.
위 그림을 보면 왜 업 캐스팅이라 부르는지 이해가 확 되지요.
그렇다면 업 캐스팅의 반대인 다운 캐스팅도 있을까요?
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : s ( "파생" ), Base () { std :: cout << "파생 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
int main () {
Base p;
Derived c;
std :: cout << "=== 포인터 버전 ===" << std :: endl;
Derived * p_p = & p;
p_p -> what ();
return 0 ;
}
컴파일 한다면 다음과 같은 오류 메세지를 볼 수 있습니다.
컴파일 오류
error C2440: 'initializing' : cannot convert from 'Base *' to 'Derived *'
사실 위와 같은 오류가 발생한 이유는 간단합니다.
만일 Derived*
포인터가 Base
객체를 가리킨다고 해봅시다. 그렇다면 p_p->what()
하게 된다면 Derived
의 what
함수가 호출되어야만 하는데, 이는 불가능 합니다. (왜냐하면 p_p
가 가리키는 객체는 Base
객체 이므로 Derived
에 대한 정보가 없습니다). 따라서, 이와 같은 문제를 막기 위해서 컴파일러 상에서 함부로 다운 캐스팅 하는 것을 금지하고 있습니다.
하지만 다음과 같은 상황은 어떨까요.
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : s ( "파생" ), Base () { std :: cout << "파생 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
int main () {
Base p;
Derived c;
std :: cout << "=== 포인터 버전 ===" << std :: endl;
Base * p_p = & c;
Derived * p_c = p_p;
p_c -> what ();
return 0 ;
}
컴파일 하였다면
컴파일 오류
error C2440: 'initializing' : cannot convert from 'Base *' to 'Derived *'
Derived* p_c
에 Base *
를 대입하면 안된다는 똑같은 오류가 발생합니다. 하지만 우리는 p_p
가 가리키는 것이 Base
객체가 아니라 Derived
객체라는 사실을 알고 있습니다. 그렇기 때문에 비록 Base *
포인터를 다운 캐스팅 함에도 불구하고 p_p
가 실제로는 Derived
객체를 가리키기 때문에
Derived * p_c = p_p;
를 해도 전혀 문제가 없습니다. 이를 위해서는 아래 처럼 강제적으로 타입 변환을 하면 됩니다.
Derived * p_c = static_cast< Derived *> (p_p);
비록 약간은 위험하지만 (만일 p_p
가 사실은 Derived
객체를 가리키지 않는다면?) 컴파일 오류를 발생시키지 않고 성공적으로 컴파일 할 수 있습니다. 그렇다면 만일 p_p
가 사실 Base
객체를 가리키는데 강제적으로 타입 변환을 해서 what
을 실행한다면 어떨까요?
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : s ( "파생" ), Base () { std :: cout << "파생 클래스" << std :: endl; }
void what () { std :: cout << s << std :: endl; }
};
int main () {
Base p;
Derived c;
std :: cout << "=== 포인터 버전 ===" << std :: endl;
Base * p_p = & p;
Derived * p_c = static_cast< Derived *> (p_p);
p_c -> what ();
return 0 ;
}
성공적으로 컴파일 하였다면
와 같은 런타임 오류가 발생하게 됩니다.
이러한 강제적으로 다운 캐스팅을 하는 경우, 컴파일 타임에서 오류를 찾아내기 매우 힘들기 때문에 다운 캐스팅은 작동이 보장되지 않는 한 매우매우 권장하지 않는 바입니다.
이러한 캐스팅에 따른 오류를 미연에 방지하기 위해서, C++ 에서는 상속 관계에 있는 두 포인터들 간에 캐스팅을 해주는 dynamic_cast
라는 것을 지원합니다. 이를 사용하는 방법은 static_cast
와 거의 동일합니다.
Derived * p_c = dyanmic_cast < Derived *> (p_p);
하지만 위의 경우 컴파일 하게 된다면
컴파일 오류
test.cc: In function 'int main()':
test.cc:27:44: error: cannot dynamic_cast 'p_p' (of type 'class Base*') to type 'class Derived*' (source type is not polymorphic)
Derived* p_c = dynamic_cast<Derived*>(p_p);
와 같이 캐스팅 할 수 없다는 컴파일 오류가 발생하게 됩니다.
자, 그럼 이제 위에서 다룬 내용을 가지고 EmployeeList
를 어떻게 하면 좀 더 간단하게 만들 수 있을 지 생각해봅시다.
class EmployeeList {
int alloc_employee; // 할당한 총 직원 수
int current_employee; // 현재 직원 수
int current_manager; // 현재 매니저 수
Employee ** employee_list; // 직원 데이터
Manager ** manager_list; // 매니저 데이터
// ...
위와 같은 구성에서 가장 문제가 되는 것이 각 클래스 별로 데이터를 따로 보관해야 된다는 것입니다. 즉 Employee
들은 Employee *
가 가리켜야 하고, Manager
들은 Manager *
가 가리켜야 합니다. 만일 무한 상사에서 클래스 하나를 더 추가해달라고 연락이 왔다간 때릴 지도 모르겠지요.
하지만, 한 가지 위에서 배운 사실은, 업 캐스팅은 매우 자유롭게 수행될 수 있다는 점입니다. 즉, Employee *
가 Manager
객체를 가리켜도 별 문제가 없다는 것이지요. 그렇다면 manager_list
를 그냥 지워 버리고, employee_list
가 Employee, Manager
상관없이 가리키게 해도 될까요? 그러면 참 좋겠지만 다음과 같은 문제점이 있습니다.
void print_employee_info () {
int total_pay = 0 ;
for ( int i = 0 ; i < current_employee; i ++ ) {
employee_list[i] -> print_info ();
total_pay += employee_list[i] -> calculate_pay ();
}
...
바로 여기서, employee_list[i]->print_info()
를 하게 되면 무조건 Employee
클래스의 print_info
함수가 호출된다는 것입니다. 왜냐하면 위에서도 이야기 하였듯이, employee_list[i]
는 Employee
객체를 가리키는 포인터 이기 때문에 자신이 가리키는 객체가 Employee
객체라고 생각합니다.
하지만 우리는 Manager
객체와 Employee
객체 모두 Employee*
가 가리키도록 하였으므로, 만일 employee_list[i]
가 가리키는 것이 Manager
객체 일 때, Manager 의 print_info
함수가 아니라 Employee
의 print_info
함수가 호출되서 다른 결과를 냅니다.
마찬가지로 calculate_pay
함수도 Manager
의 calculate_pay
가 호출 되어야 하는데 Employee
의 calculate_pay
가 호출되어서 (월급이 더 적게나오는 ㅠㅠ) 틀린 결과가 나옵니다. 나쁜 회사였으면 환영할 일이였겠지만 착한 우리의 입장에선 이 문제를 꼭 해결해야 합니다.
실제로,
#include <iostream>
#include <string>
class Employee {
protected:
std :: string name;
int age;
std :: string position; // 직책 (이름)
int rank; // 순위 (값이 클 수록 높은 순위)
public:
Employee (std :: string name, int age, std :: string position, int rank)
: name (name), age (age), position (position), rank (rank) {}
// 복사 생성자
Employee ( const Employee & employee) {
name = employee . name;
age = employee . age;
position = employee . position;
rank = employee . rank;
}
// 디폴트 생성자
Employee () {}
void print_info () {
std :: cout << name << " (" << position << " , " << age << ") ==> "
<< calculate_pay () << "만원" << std :: endl;
}
int calculate_pay () { return 200 + rank * 50 ; }
};
class Manager : public Employee {
int year_of_service;
public:
Manager (std :: string name, int age, std :: string position, int rank,
int year_of_service)
: year_of_service (year_of_service), Employee (name, age, position, rank) {}
// 복사 생성자
Manager ( const Manager & manager)
: Employee (manager . name, manager . age, manager . position, manager . rank) {
year_of_service = manager . year_of_service;
}
// 디폴트 생성자
Manager () : Employee () {}
int calculate_pay () { return 200 + rank * 50 + 5 * year_of_service; }
void print_info () {
std :: cout << name << " (" << position << " , " << age << ", "
<< year_of_service << "년차) ==> " << calculate_pay () << "만원"
<< std :: endl;
}
};
class EmployeeList {
int alloc_employee; // 할당한 총 직원 수
int current_employee; // 현재 직원 수
Employee ** employee_list; // 직원 데이터
public:
EmployeeList ( int alloc_employee) : alloc_employee (alloc_employee) {
employee_list = new Employee * [alloc_employee];
current_employee = 0 ;
}
void add_employee (Employee * employee) {
// 사실 current_employee 보다 alloc_employee 가 더
// 많아지는 경우 반드시 재할당을 해야 하지만, 여기서는
// 최대한 단순하게 생각해서 alloc_employee 는
// 언제나 current_employee 보다 크다고 생각한다.
// (즉 할당된 크기는 현재 총 직원수 보다 많음)
employee_list[current_employee] = employee;
current_employee ++ ;
}
int current_employee_num () { return current_employee; }
void print_employee_info () {
int total_pay = 0 ;
for ( int i = 0 ; i < current_employee; i ++ ) {
employee_list[i] -> print_info ();
total_pay += employee_list[i] -> calculate_pay ();
}
std :: cout << "총 비용 : " << total_pay << "만원 " << std :: endl;
}
~ EmployeeList () {
for ( int i = 0 ; i < current_employee; i ++ ) {
delete employee_list[i];
}
delete [] employee_list;
}
};
int main () {
EmployeeList emp_list ( 10 );
emp_list . add_employee ( new Employee ( "노홍철" , 34 , "평사원" , 1 ));
emp_list . add_employee ( new Employee ( "하하" , 34 , "평사원" , 1 ));
emp_list . add_employee ( new Manager ( "유재석" , 41 , "부장" , 7 , 12 ));
emp_list . add_employee ( new Manager ( "정준하" , 43 , "과장" , 4 , 15 ));
emp_list . add_employee ( new Manager ( "박명수" , 43 , "차장" , 5 , 13 ));
emp_list . add_employee ( new Employee ( "정형돈" , 36 , "대리" , 2 ));
emp_list . add_employee ( new Employee ( "길" , 36 , "인턴" , - 2 ));
emp_list . print_employee_info ();
return 0 ;
}
성공적으로 컴파일 하였다면
실행 결과
노홍철 (평사원 , 34) ==> 250만원
하하 (평사원 , 34) ==> 250만원
유재석 (부장 , 41) ==> 550만원
정준하 (과장 , 43) ==> 400만원
박명수 (차장 , 43) ==> 450만원
정형돈 (대리 , 36) ==> 300만원
길 (인턴 , 36) ==> 100만원
총 비용 : 2300만원
와 같이 전부다 Employee
의 print_info
와 calculate_pay
함수가 호출되서 원래 결과와 달라집니다.
그런데 놀랍게도 이러한 문제를 5초 만에 해결할 수 있는 방법이 있습니다.
EmployeeList
문제를 해결하기 전에 좀 더 간단한 예시로 살펴보겠습니다.
#include <iostream>
class Base {
public:
Base () { std :: cout << "기반 클래스" << std :: endl; }
virtual void what () { std :: cout << "기반 클래스의 what()" << std :: endl; }
};
class Derived : public Base {
public:
Derived () : Base () { std :: cout << "파생 클래스" << std :: endl; }
void what () { std :: cout << "파생 클래스의 what()" << std :: endl; }
};
int main () {
Base p;
Derived c;
Base * p_c = & c;
Base * p_p = & p;
std :: cout << " == 실제 객체는 Base == " << std :: endl;
p_p -> what ();
std :: cout << " == 실제 객체는 Derived == " << std :: endl;
p_c -> what ();
return 0 ;
}
성공적으로 컴파일 하였다면
실행 결과
기반 클래스
기반 클래스
파생 클래스
== 실제 객체는 Base ==
기반 클래스의 what()
== 실제 객체는 Derived ==
파생 클래스의 what()
어라? 위 결과를 보셨다면 놀라움을 금치 못하셨을 것입니다.
Base * p_c = & c;
Base * p_p = & p;
std :: cout << " == 실제 객체는 Base == " << std :: endl;
p_p -> what ();
std :: cout << " == 실제 객체는 Derived == " << std :: endl;
p_c -> what ();
분명히 여기서 p_p
와 p_c
모두 Base
객체를 가리키는 포인터 입니다. 따라서, p_p->what()
와 p_c->what()
을 하면 모두 Base
객체의 what()
함수가 실행되서 둘 다 '기반' 라고 출력이 되어야만 했습니다.
그런데, 놀랍게도, 실제 p_p
와 p_c
가 무엇과 결합해 있는지 아는 것 처럼 (p_p
는 Base
객체를 가리키고, p_c
는 Derived
객체를 가리킴) 이에 따른 적절한 what
함수를 호출해준 것입니다.
이와 같은 일이 가능해진 이유는 바로;
class Base {
public:
Base () { std :: cout << "기반 클래스" << std :: endl; }
virtual void what () { std :: cout << "기반 클래스의 what()" << std :: endl; }
};
이 virtual
키워드 하나 때문입니다. 이 virtual
키워드는, 다음과 같은 역할을 합니다.
p_c -> what ();
위 코드를 실행시에 (런타임), 컴퓨터 입장에서;
"흠, p_c 는 Base 포인터니까 Base 의 what() 을 실행해야지"
"어 근데 what 이 virtual 이네?"
"잠깐. 이거 실제 Base 객체 맞어? 아니네 Derived 객체네"
"그럼 Derived 의 what 을 실행해야지"
반면에
p_p -> what ();
였을 경우에는
"흠, p_c 는 Base 포인터니까 Base 의 what() 을 실행해야지"
"어 근데 what 이 virtual 이네?"
"잠깐. 이거 실제 Base 객체 맞어? 어 맞네."
"Base 의 what 을 실행하자"
이렇게 컴파일 시에 어떤 함수가 실행될 지 정해지지 않고 런타임 시에 정해지는 일을 가리켜서 동적 바인딩(dynamic binding) 이라고 부릅니다. 즉,
p_c -> what ();
에서 Derived
의 what
을 실행할지, Base
의 what
을 실행하지 결정은 런타임에 이루어지게 됩니다. 물론 위 코드에선 컴파일 시에 무조건 p_c->what()
이 Derived
의 what
이 실행되도록 정해진 거 아니냐고 물을 수 있지만 다음과 같은 상황을 생각해보세요.
// i 는 사용자로부터 입력받는 변수
if (i == 1 ) {
p_p = & c;
} else {
p_p = & p;
}
p_p -> what ();
이렇게 된다면 p_p->what()
이 어떤 what
일지에는 런타임에 정해지겠지요? 물론 동적 바인딩의 반대말로 정적 바인딩(static binding) 이란 말도 있습니다. 이는 컴파일 타임에 어떤 함수가 호출될 지 정해지는 것으로 여태까지 여러분이 알고 오셨던 함수에 해당합니다.
덧붙여서, virtual
키워드가 붙은 함수를 가상 함수(virtual function) 라고 부릅니다. 이렇게 파생 클래스의 함수가 기반 클래스의 함수를 오버라이드 하기 위해서는 두 함수의 꼴이 정확히 같아야 합니다.
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
virtual void what () { std :: cout << s << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : s ( "파생" ), Base () { std :: cout << "파생 클래스" << std :: endl; }
void what () override { std :: cout << s << std :: endl; }
};
C++ 11 에서는 파생 클래스에서 기반 클래스의 가상 함수를 오버라이드 하는 경우, override
키워드를 통해서 명시적으로 나타낼 수 있습니다.
void what () override { std :: cout << s << std :: endl; }
위 경우 Derived
클래스의 what
함수는 Base
클래스의 what
함수를 오버라이드 하므로, override
키워드를 통해 이를 알려주고 있습니다.
override
키워드를 사용하게 되면, 실수로 오버라이드를 하지 않는 경우를 막을 수 있습니다. 예를 들어서;
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
virtual void incorrect () { std :: cout << "기반 클래스 " << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : Base (), s ( "파생" ) {}
void incorrect () const { std :: cout << "파생 클래스 " << std :: endl; }
};
int main () {
Base p;
Derived c;
Base * p_c = & c;
Base * p_p = & p;
std :: cout << " == 실제 객체는 Base == " << std :: endl;
p_p -> incorrect ();
std :: cout << " == 실제 객체는 Derived == " << std :: endl;
p_c -> incorrect ();
return 0 ;
}
성공적으로 컴파일 하였다면
실행 결과
기반 클래스
기반 클래스
== 실제 객체는 Base ==
기반 클래스
== 실제 객체는 Derived ==
기반 클래스
와 같이 incorrect
함수가 제대로 오버라이드 되지 않았음을 알 수 있습니다. 그 이유는 Base
의 incorrect
함수와 Derived
의 incorrect
함수는 거의 똑같이 생기기는 했지만 사실 다르기 때문입니다. 왜냐하면 Derived
의 incorrect
함수는 상수 함수 이고, Base
의 incorrect
는 아니기 때문이지요.
따라서 컴파일러 입장에서 두 함수는 다른 함수로 간주되므로, p_c->incorrect()
를 하였을 때 Derived
의 incorrect
함수가 Base
의 incorrect
함수를 오버라이드 하는 것이 아니라, 그냥 Base
의 incorrect
함수를 호출하는 셈이 됩니다.
만약에 여러분의 의도가 Derived
의 incorrect
함수가 기반 클래스를 오버라이드 하는 것이였다면 큰 문제가 될 것입니다. 이 버그는 컴파일 타임에 잡을 수 없게 되니까요.
하지만, 실제로 Derived
의 incorrect
함수를 기반 클래스의 incorrect
함수를 오버라이드 하기 위해서 만들었다면, override
키워드를 써야겠지요.
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
virtual void incorrect () { std :: cout << "기반 클래스 " << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : Base (), s ( "파생" ) {}
void incorrect () const override { std :: cout << "파생 클래스 " << std :: endl; }
};
int main () {
Base p;
Derived c;
Base * p_c = & c;
Base * p_p = & p;
std :: cout << " == 실제 객체는 Base == " << std :: endl;
p_p -> incorrect ();
std :: cout << " == 실제 객체는 Derived == " << std :: endl;
p_c -> incorrect ();
return 0 ;
}
컴파일 하였다면
컴파일 오류
test.cc:19:8: error: 'void Derived::incorrect() const' marked 'override', but does not override
위와 같이 Derived
의 incorrect
함수가 override
한다고 써있지만, 실제로는 아무것도 오버라이드 하지 않는다고 오류가 발생하게 됩니다. 만일 const
키워드를 지워준다면
#include <iostream>
#include <string>
class Base {
std :: string s;
public:
Base () : s ( "기반" ) { std :: cout << "기반 클래스" << std :: endl; }
virtual void incorrect () { std :: cout << "기반 클래스 " << std :: endl; }
};
class Derived : public Base {
std :: string s;
public:
Derived () : Base (), s ( "파생" ) {}
void incorrect () override { std :: cout << "파생 클래스 " << std :: endl; }
};
int main () {
Base p;
Derived c;
Base * p_c = & c;
Base * p_p = & p;
std :: cout << " == 실제 객체는 Base == " << std :: endl;
p_p -> incorrect ();
std :: cout << " == 실제 객체는 Derived == " << std :: endl;
p_c -> incorrect ();
return 0 ;
}
성공적으로 컴파일 하였다면
실행 결과
기반 클래스
기반 클래스
== 실제 객체는 Base ==
기반 클래스
== 실제 객체는 Derived ==
파생 클래스
제대로 실행됨을 알 수 있습니다.
이제 여러분은 그동안 골머리를 썩여왔던 EmployeeList
문제도 해결할 수 있게 되었습니다. 단순히 Employee
클래스의 calculate_pay
함수와 print_info
함수 앞에 virtual
만 붙여주면 깔끔하게 정리 되지요.
#include <iostream>
#include <string>
class Employee {
protected:
std :: string name;
int age;
std :: string position; // 직책 (이름)
int rank; // 순위 (값이 클 수록 높은 순위)
public:
Employee (std :: string name, int age, std :: string position, int rank)
: name (name), age (age), position (position), rank (rank) {}
// 복사 생성자
Employee ( const Employee & employee) {
name = employee . name;
age = employee . age;
position = employee . position;
rank = employee . rank;
}
// 디폴트 생성자
Employee () {}
virtual void print_info () {
std :: cout << name << " (" << position << " , " << age << ") ==> "
<< calculate_pay () << "만원" << std :: endl;
}
virtual int calculate_pay () { return 200 + rank * 50 ; }
};
class Manager : public Employee {
int year_of_service;
public:
Manager (std :: string name, int age, std :: string position, int rank,
int year_of_service)
: year_of_service (year_of_service), Employee (name, age, position, rank) {}
int calculate_pay () override { return 200 + rank * 50 + 5 * year_of_service; }
void print_info () override {
std :: cout << name << " (" << position << " , " << age << ", "
<< year_of_service << "년차) ==> " << calculate_pay () << "만원"
<< std :: endl;
}
};
class EmployeeList {
int alloc_employee; // 할당한 총 직원 수
int current_employee; // 현재 직원 수
Employee ** employee_list; // 직원 데이터
public:
EmployeeList ( int alloc_employee) : alloc_employee (alloc_employee) {
employee_list = new Employee * [alloc_employee];
current_employee = 0 ;
}
void add_employee (Employee * employee) {
// 사실 current_employee 보다 alloc_employee 가 더
// 많아지는 경우 반드시 재할당을 해야 하지만, 여기서는
// 최대한 단순하게 생각해서 alloc_employee 는
// 언제나 current_employee 보다 크다고 생각한다.
// (즉 할당된 크기는 현재 총 직원수 보다 많음)
employee_list[current_employee] = employee;
current_employee ++ ;
}
int current_employee_num () { return current_employee; }
void print_employee_info () {
int total_pay = 0 ;
for ( int i = 0 ; i < current_employee; i ++ ) {
employee_list[i] -> print_info ();
total_pay += employee_list[i] -> calculate_pay ();
}
std :: cout << "총 비용 : " << total_pay << "만원 " << std :: endl;
}
~ EmployeeList () {
for ( int i = 0 ; i < current_employee; i ++ ) {
delete employee_list[i];
}
delete [] employee_list;
}
};
int main () {
EmployeeList emp_list ( 10 );
emp_list . add_employee ( new Employee ( "노홍철" , 34 , "평사원" , 1 ));
emp_list . add_employee ( new Employee ( "하하" , 34 , "평사원" , 1 ));
emp_list . add_employee ( new Manager ( "유재석" , 41 , "부장" , 7 , 12 ));
emp_list . add_employee ( new Manager ( "정준하" , 43 , "과장" , 4 , 15 ));
emp_list . add_employee ( new Manager ( "박명수" , 43 , "차장" , 5 , 13 ));
emp_list . add_employee ( new Employee ( "정형돈" , 36 , "대리" , 2 ));
emp_list . add_employee ( new Employee ( "길" , 36 , "인턴" , - 2 ));
emp_list . print_employee_info ();
return 0 ;
}
성공적으로 컴파일 하였다면
실행 결과
노홍철 (평사원 , 34) ==> 250만원
하하 (평사원 , 34) ==> 250만원
유재석 (부장 , 41, 12년차) ==> 610만원
정준하 (과장 , 43, 15년차) ==> 475만원
박명수 (차장 , 43, 13년차) ==> 515만원
정형돈 (대리 , 36) ==> 300만원
길 (인턴 , 36) ==> 100만원
총 비용 : 2500만원
와 같이 비록 Employee*
가 가리키고 있음에도 불구하고 Manager
면 Manager
의 함수를, Employee
면 Employee
의 함수를 잘 호출하고 있음을 알 수 있습니다. 물론 바뀐 것은 단 두 단어. virtual
키워들을 Employee
의 함수들 앞에 추가해놓은 것 뿐이지요.
employee_list[i] -> print_info ();
total_pay += employee_list[i] -> calculate_pay ();
이 두 부분은 employee_list[i]
가 Employee
냐 Manager
에 따라서 다르게 동작하게 됩니다. 이렇게 같은 print_info
함수를 호출했음에도 불구하고 어떤 경우는 Employee
의 것이, 어떤 경우는 Manager
의 것이 호출되는 일; 즉 하나의 메소드를 호출했음에도 불구하고 여러가지 다른 작업들을 하는 것을 바로 다형성(polymorphism) 이라고 부릅니다.
참고로, 다형성을 뜻하는 영어 단어인 polymorphism 은,여러개를 의미하는 그리스어 'poly' 와, 모습, 모양을 뜻하는 그리스어 'morphism' 에서 온 단어로 '여러가지 형태' 라는 의미 입니다.
자 그러면 이번 강좌는 여기에서 마치도록 하겠습니다. 아마도 virtual
키워드를 처음 접했더라면 머가 어떻게 되는지 많이 헷갈릴 수 있는데 꼭 여러번 테스트 프로그램을 만들어보아서 확실히 이해하고 넘어가도록 합시다 :)
그렇다면 프로그램 내부적으로 virtual
함수들은 어떻게 처리될까요? 즉, 이 포인터가 어떠한 객체를 가리키는지 어떻게 알 수 있을까요? (난이도 : 上)
강좌를 보다가 조금이라도
궁금한 것이나 이상한 점이 있다면 꼭 댓글 을 남겨주시기 바랍니다. 그 외에도 강좌에 관련된 것이라면 어떠한 것도 질문해 주셔도 상관 없습니다. 생각해 볼 문제도 정 모르겠다면 댓글을 달아주세요.
현재 여러분이 보신 강좌는
<씹어먹는 C++ - <6 - 2. 가상(virtual) 함수와 다형성>> 입니다. 이번 강좌의 모든 예제들의 코드를 보지 않고 짤 수준까지 강좌를 읽어 보시기 전까지 다음 강좌로 넘어가지 말아주세요
 이전 강좌
씹어먹는 C++ - <6 - 1. C++ 표준 문자열 & 부모의 것을 물려쓰자 - 상속>
다음 강좌 
씹어먹는 C++ - <6 - 3. 가상함수와 상속에 관련한 잡다한 내용들>
{"":{"C":{"files":["231","315","5","6","19","21","7","8","308","9","10","12","14","16","17","18","20","23","24","25","26","27","28","30","31","29","32","33","43","55","60","71","83","87","88","89","98","100","99","103","117","123","125","129","130","184","187","214"]},"C Reference":{"files":[],"stdio.h":{"files":["34","37","38","39","40","41","44","45","36","46","47","48","49","50","51","52","54","53","57","58","59","61","62","64","65","66","68","69","70","72","73","74","75","35","67"]},"stdlib.h":{"files":["244","243","121","124","131","132","139","140"]},"string.h":{"files":["77","76","78","79","80","81","82","84","85","86","92","90","91","93","94","95","96","97","101","102","104","105","106"]},"time.h":{"files":["110","111","109","108","113","116","112","114","118","119","120","122"]}},"C++":{"files":["135","134","136","138","141","169","172","173","188","197","198","253","202","203","204","209","210","211","213","215","217","218","219","290","221","222","223","224","225","292","230","227","228","229","252","254","269","270","271","284","285","286","293","294","295","303","304","306","309","310","311","332","319","320","321","322","326","335","189","195","196","208","220","255","312"]},"C++ Reference":{"Containers":{"deque":{"files":["176"]},"files":["174"],"list":{"files":["177"]},"vector":{"files":["175","178","183","186","185"]}},"algorithm":{"files":["256","257","258","261","260","259","262","265","263","264","267","266","272","273","275","288","289","291","298","305","317","318","268","324","323","325"]},"array":{"files":["314"]},"files":[],"iostream":{"files":["143","145","144","146","147","151","150","152","149","153","154","157","155","156","160","158","159","161","163","162","166","167","165","164","168","170","180","181","182","171","179","190","192","191","193","194","276","279","277","278","280","281","282","283"]},"string":{"files":["234","233","237","240","241","249","236","238","250","235","297","296","307"]},"string_view":{"files":["239","242"]},"utility":{"files":["299","301","302"]}},"Rust":{"files":["333","334"]},"X86-64 명령어 레퍼런스":{"A":{"files":["aaa","aad","aam","aas","adc","adcx","add","addpd","addps","addsd","addss","addsubpd","addsubps","adox","aesdec","aesdeclast","aesenc","aesenclast","aesimc","aeskeygenassist","and","andn","andnpd","andnps","andpd","andps","arpl"]},"B":{"files":["bextr","blendpd","blendps","blendvpd","blendvps","blsi","blsmsk","blsr","bndcl","bndcu-bndcn","bndldx","bndmk","bndmov","bndstx","bound","bsf","bsr","bswap","bt","btc","btr","bts","bzhi"]},"C":{"files":["call","cbw-cwde-cdqe","clac","clc","cld","clflush","clflushopt","cli","clts","clwb","cmc","cmovcc","cmp","cmppd","cmpps","cmps-cmpsb-cmpsw-cmpsd-cmpsq","cmpsd","cmpss","cmpxchg","cmpxchg8b-cmpxchg16b","comisd","comiss","cpuid","crc32","cvtdq2pd","cvtdq2ps","cvtpd2dq","cvtpd2pi","cvtpd2ps","cvtpi2pd","cvtpi2ps","cvtps2dq","cvtps2pd","cvtps2pi","cvtsd2si","cvtsd2ss","cvtsi2sd","cvtsi2ss","cvtss2sd","cvtss2si","cvttpd2dq","cvttpd2pi","cvttps2dq","cvttps2pi","cvttsd2si","cvttss2si","cwd-cdq-cqo"]},"D":{"files":["daa","das","dec","div","divpd","divps","divsd","divss","dppd","dpps"]},"E":{"files":["emms","enter","extractps"]},"F":{"files":["f2xm1","fabs","fadd-faddp-fiadd","fbld","fbstp","fchs","fclex-fnclex","fcmovcc","fcom-fcomp-fcompp","fcomi-fcomip--fucomip","fcos","fdecstp","fdiv-fdivp-fidiv","fdivr-fdivrp-fidivr","ffree","ficom-ficomp","fild","fincstp","finit-fninit","fist-fistp","fisttp","fld","fld1-fldl2t-fldl2e-fldpi-fldlg2-fldln2-fldz","fldcw","fldenv","fmul-fmulp-fimul","fnop","fpatan","fprem","fprem1","fptan","frndint","frstor","fsave-fnsave","fscale","fsin","fsincos","fsqrt","fst-fstp","fstcw-fnstcw","fstenv-fnstenv","fstsw-fnstsw","fsub-fsubp-fisub","fsubr-fsubrp-fisubr","ftst","fucom-fucomp-fucompp","fxam","fxch","fxrstor","fxsave","fxtract","fyl2x","fyl2xp1"]},"G":{"files":["getsec[exitac]","getsec[parameters]","getsec[senter]","getsec[sexit]","getsec[smctrl]","getsec[wakeup]"]},"H":{"files":["haddpd","haddps","hlt","hsubpd","hsubps"]},"I":{"files":["idiv","imul","in","inc","ins-insb-insw-insd","insertps","int n-into-int 3","invd","invlpg","invpcid","iret-iretd"]},"J":{"files":["jmp","jcc"]},"K":{"files":["kaddw-kaddb-kaddq-kaddd","kandnw-kandnb-kandnq-kandnd","kandw-kandb-kandq-kandd","kmovw-kmovb-kmovq-kmovd","knotw-knotb-knotq-knotd","kortestw-kortestb-kortestq-kortestd","korw-korb-korq-kord","kshiftlw-kshiftlb-kshiftlq-kshiftld","kshiftrw-kshiftrb-kshiftrq-kshiftrd","ktestw-ktestb-ktestq-ktestd","kunpckbw-kunpckwd-kunpckdq","kxnorw-kxnorb-kxnorq-kxnord","kxorw-kxorb-kxorq-kxord"]},"L":{"files":["lahf","lar","lddqu","ldmxcsr","lds-les-lfs-lgs-lss","lea","leave","lfence","lgdt-lidt","lldt","lmsw","lock","lods-lodsb-lodsw-lodsd-lodsq","loop-loopcc","lsl","ltr","lzcnt"]},"M":{"files":["maskmovdqu","maskmovq","maxpd","maxps","maxsd","maxss","mfence","minpd","minps","minsd","minss","monitor","mov_2","mov","mov_1","movapd","movaps","movbe","movd-movq","movddup","movdq2q","movdqa-vmovdqa32-vmovdqa64","movdqu-vmovdqu8-vmovdqu16-vmovdqu32-vmovdqu64","movhlps","movhpd","movhps","movlhps","movlpd","movlps","movmskpd","movmskps","movntdq","movntdqa","movnti","movntpd","movntps","movntq","movq","movq2dq","movs-movsb-movsw-movsd-movsq","movsd","movshdup","movsldup","movss","movsx-movsxd","movupd","movups","movzx","mpsadbw","mul","mulpd","mulps","mulsd","mulss","mulx","mwait"]},"N":{"files":["neg","nop","not"]},"O":{"files":["or","orpd","orps","out","outs-outsb-outsw-outsd"]},"P":{"files":["pabsb-pabsw-pabsd-pabsq","packsswb-packssdw","packusdw","packuswb","paddb-paddw-paddd-paddq","paddsb-paddsw","paddusb-paddusw","palignr","pand","pandn","pause","pavgb-pavgw","pblendvb","pblendw","pcmpeqb-pcmpeqw-pcmpeqd","pcmpeqq","pcmpestri","pcmpestrm","pcmpgtb-pcmpgtw-pcmpgtd","pcmpgtq","pcmpistri","pcmpistrm","pdep","pext","pextrb-pextrd-pextrq","pextrw","phaddsw","phaddw-phaddd","phminposuw","phsubsw","phsubw-phsubd","pinsrb-pinsrd-pinsrq","pinsrw","pmaddubsw","pmaddwd","pmaxsb-pmaxsw-pmaxsd-pmaxsq","pmaxub-pmaxuw","pmaxud-pmaxuq","pminsb-pminsw","pminsd-pminsq","pminub-pminuw","pminud-pminuq","pmovmskb","pmovsx","pmovzx","pmuldq","pmulhrsw","pmulhuw","pmulhw","pmulld-pmullq","pmullw","pmuludq","pop","popa-popad","popcnt","popf-popfd-popfq","por","prefetchw","prefetchwt1","prefetchh","prold-prolvd-prolq-prolvq","prord-prorvd-prorq-prorvq","psadbw","pshufb","pshufd","pshufhw","pshuflw","pshufw","psignb-psignw-psignd","pslldq","psllw-pslld-psllq","psraw-psrad-psraq","psrldq","psrlw-psrld-psrlq","psubb-psubw-psubd","psubq","psubsb-psubsw","psubusb-psubusw","punpckhbw-punpckhwd-punpckhdq-punpckhqdq","punpcklbw-punpcklwd-punpckldq-punpcklqdq","push","pusha-pushad","pushf-pushfd","pxor"]},"R":{"files":["rcl-rcr-rol-ror","rcpps","rcpss","rdfsbase-rdgsbase","rdmsr","rdpid","rdpkru","rdpmc","rdrand","rdseed","rdtsc","rdtscp","rep-repe-repz-repne-repnz","ret","rorx","roundpd","roundps","roundsd","roundss","rsm","rsqrtps","rsqrtss"]},"S":{"files":["sahf","sal-sar-shl-shr","sarx-shlx-shrx","sbb","scas-scasb-scasw-scasd","setcc","sfence","sgdt","sha1msg1","sha1msg2","sha1nexte","sha1rnds4","sha256msg1","sha256msg2","sha256rnds2","shld","shrd","shufpd","shufps","sidt","sldt","smsw","sqrtpd","sqrtps","sqrtsd","sqrtss","stac","stc","std","sti","stmxcsr","stos-stosb-stosw-stosd-stosq","str","sub","subpd","subps","subsd","subss","swapgs","syscall","sysenter","sysexit","sysret"]},"T":{"files":["test","tzcnt"]},"U":{"files":["ucomisd","ucomiss","ud2","unpckhpd","unpckhps","unpcklpd","unpcklps"]},"V":{"files":["valignd-valignq","vblendmpd-vblendmps","vbroadcast","vcompresspd","vcompressps","vcvtpd2qq","vcvtpd2udq","vcvtpd2uqq","vcvtph2ps","vcvtps2ph","vcvtps2qq","vcvtps2udq","vcvtps2uqq","vcvtqq2pd","vcvtqq2ps","vcvtsd2usi","vcvtss2usi","vcvttpd2qq","vcvttpd2udq","vcvttpd2uqq","vcvttps2qq","vcvttps2udq","vcvttps2uqq","vcvttsd2usi","vcvttss2usi","vcvtudq2pd","vcvtudq2ps","vcvtuqq2pd","vcvtuqq2ps","vcvtusi2sd","vcvtusi2ss","vdbpsadbw","verr-verw","vexp2pd","vexp2ps","vexpandpd","vexpandps","vextractf128-vextractf32x4-vextractf64x2-vextractf32x8-vextractf64x4","vextracti128-vextracti32x4-vextracti64x2-vextracti32x8-vextracti64x4","vfixupimmpd","vfixupimmps","vfixupimmsd","vfixupimmss","vfmadd132pd-vfmadd213pd-vfmadd231pd","vfmadd132ps-vfmadd213ps-vfmadd231ps","vfmadd132sd-vfmadd213sd-vfmadd231sd","vfmadd132ss-vfmadd213ss-vfmadd231ss","vfmaddsub132pd-vfmaddsub213pd-vfmaddsub231pd","vfmaddsub132ps-vfmaddsub213ps-vfmaddsub231ps","vfmsub132pd-vfmsub213pd-vfmsub231pd","vfmsub132ps-vfmsub213ps-vfmsub231ps","vfmsub132sd-vfmsub213sd-vfmsub231sd","vfmsub132ss-vfmsub213ss-vfmsub231ss","vfmsubadd132pd-vfmsubadd213pd-vfmsubadd231pd","vfmsubadd132ps-vfmsubadd213ps-vfmsubadd231ps","vfnmadd132pd-vfnmadd213pd-vfnmadd231pd","vfnmadd132ps-vfnmadd213ps-vfnmadd231ps","vfnmadd132sd-vfnmadd213sd-vfnmadd231sd","vfnmadd132ss-vfnmadd213ss-vfnmadd231ss","vfnmsub132pd-vfnmsub213pd-vfnmsub231pd","vfnmsub132ps-vfnmsub213ps-vfnmsub231ps","vfnmsub132sd-vfnmsub213sd-vfnmsub231sd","vfnmsub132ss-vfnmsub213ss-vfnmsub231ss","vfpclasspd","vfpclassps","vfpclasssd","vfpclassss","vgatherdpd-vgatherqpd","vgatherdps-vgatherdpd","vgatherdps-vgatherqps","vgatherpf0dps-vgatherpf0qps-vgatherpf0dpd-vgatherpf0qpd","vgatherpf1dps-vgatherpf1qps-vgatherpf1dpd-vgatherpf1qpd","vgatherqps-vgatherqpd","vgetexppd","vgetexpps","vgetexpsd","vgetexpss","vgetmantpd","vgetmantps","vgetmantsd","vgetmantss","vinsertf128-vinsertf32x4-vinsertf64x2-vinsertf32x8-vinsertf64x4","vinserti128-vinserti32x4-vinserti64x2-vinserti32x8-vinserti64x4","vmaskmov","vpblendd","vpblendmb-vpblendmw","vpblendmd-vpblendmq","vpbroadcast","vpbroadcastb-vpbroadcastw-vpbroadcastd-vpbroadcastq","vpbroadcastm","vpcmpb-vpcmpub","vpcmpd-vpcmpud","vpcmpq-vpcmpuq","vpcmpw-vpcmpuw","vpcompressd","vpcompressq","vpconflictd-vpconflictq","vperm2f128","vperm2i128","vpermd-vpermw","vpermi2w-vpermi2d-vpermi2q-vpermi2ps-vpermi2pd","vpermilpd","vpermilps","vpermpd","vpermps","vpermq","vpexpandd","vpexpandq","vpgatherdd-vpgatherdq","vpgatherdd-vpgatherqd","vpgatherdq-vpgatherqq","vpgatherqd-vpgatherqq","vplzcntd-vplzcntq","vpmaskmov","vpmovb2m-vpmovw2m-vpmovd2m-vpmovq2m","vpmovdb-vpmovsdb-vpmovusdb","vpmovdw-vpmovsdw-vpmovusdw","vpmovm2b-vpmovm2w-vpmovm2d-vpmovm2q","vpmovqb-vpmovsqb-vpmovusqb","vpmovqd-vpmovsqd-vpmovusqd","vpmovqw-vpmovsqw-vpmovusqw","vpmovwb-vpmovswb-vpmovuswb","vpscatterdd-vpscatterdq-vpscatterqd-vpscatterqq","vpsllvw-vpsllvd-vpsllvq","vpsravw-vpsravd-vpsravq","vpsrlvw-vpsrlvd-vpsrlvq","vpternlogd-vpternlogq","vptestmb-vptestmw-vptestmd-vptestmq","vptestnmb-vptestnmw-vptestnmd-vptestnmq","vrangepd","vrangesd","vrangess","vrcp14pd","vrcp14ps","vrcp14sd","vrcp14ss","vrcp28pd","vrcp28ps","vrcp28sd","vrcp28ss","vreducepd","vreduceps","vreducess","vrndscalepd","vrndscaleps","vrndscalesd","vrndscaless","vrsqrt14pd","vrsqrt14ps","vrsqrt14sd","vrsqrt14ss","vrsqrt28pd","vrsqrt28ps","vrsqrt28sd","vrsqrt28ss","vscalefpd","vscalefps","vscalefsd","vscalefss","vscatterdps-vscatterdpd-vscatterqps-vscatterqpd","vscatterpf0dps-vscatterpf0qps-vscatterpf0dpd-vscatterpf0qpd","vscatterpf1dps-vscatterpf1qps-vscatterpf1dpd-vscatterpf1qpd","vshuff32x4-vshuff64x2-vshufi32x4-vshufi64x2","vtestpd-vtestps","vzeroall","vzeroupper"]},"W":{"files":["wait-fwait","wbinvd","wrfsbase-wrgsbase","wrmsr","wrpkru"]},"X":{"files":["xabort","xacquire-xrelease","xadd","xbegin","xchg","xend","xgetbv","xlat-xlatb","xor","xorpd","xorps","xrstor","xrstors","xsave","xsavec","xsaveopt","xsaves","xsetbv","xtest"]},"files":["316"]},"files":[],"알고리즘":{"files":["246","247","248","274","287","245"]},"자료 구조":{"files":["328","329"]},"잡담":{"files":["232","115","142","300","327"],"본인 소개":{"files":["251"]}},"프로그래밍":{"files":["199","201","313"]}},"files":[]}
{"5":{"cat_title":"1. C 언어가 뭐야?","chapter":"C 언어의 세계로","next_page":"6","path":"/C","prev_page":"315","publish_date":"2009-04-16","title":"씹어먹는 C 언어 - <1. C 언어가 뭐야?>"},"6":{"cat_title":"2 - 1. C 언어 본격 맛보기","next_page":"19","path":"/C","prev_page":"5","publish_date":"2009-04-17","tex_title":"C 언어 본격 맛보기","title":"씹어먹는 C 언어 - <2 - 1. C 언어 본격 맛보기>"},"7":{"cat_title":"3. 변수가 뭐지?","chapter":"변수 (variable)","next_page":"8","path":"/C","prev_page":"21","publish_date":"2009-04-22","title":"씹어먹는 C 언어 - <3. 변수가 뭐지? >"},"8":{"cat_title":"4 - 1. 계산하리","chapter":"계산 하기","next_page":"308","path":"/C","prev_page":"7","publish_date":"2009-04-24","title":"씹어먹는 C 언어 - <4 - 1. 계산하리>"},"9":{"cat_title":"5. 문자 입력 받기","chapter":"문자 입력 받기","next_page":"10","path":"/C","prev_page":"308","publish_date":"2009-04-27","title":"씹어먹는 C 언어 - <5. 문자 입력 받기>"},"10":{"cat_title":"6. 만약에... (if 문)","chapter":"만약에... (조건문)","next_page":"12","path":"/C","prev_page":"9","publish_date":"2009-04-28","title":"씹어먹는 C 언어 - <6. 만약에...(if 문)>"},"12":{"cat_title":"7. 뱅글 뱅글 (for, while)","chapter":"반복문 (for, while)","next_page":"14","path":"/C","prev_page":"10","publish_date":"2009-08-06","title":"씹어먹는 C 언어 - <7. 뱅글 뱅글 (for, while) >"},"14":{"cat_title":"8. 우분투 리눅스에서 C 프로그래밍 하기","next_page":"16","path":"/C","prev_page":"12","publish_date":"2009-08-06","tex_title":"리눅스에서 C 프로그래밍 하기","title":"씹어 먹는 C 언어 - <8. 우분투 리눅스에서 C 프로그래밍 하기>"},"16":{"cat_title":"9. 만약에... 2탄 (switch 문)","chapter":"switch 문","next_page":"17","path":"/C","prev_page":"14","publish_date":"2009-08-15","title":"씹어먹는 C 언어 - <9. 만약에... 2탄 (switch 문)>"},"17":{"cat_title":"10. 연예인 캐스팅(?) (C 언어에서의 형 변환)","chapter":"형 변환 (타입 캐스팅)","next_page":"18","path":"/C","prev_page":"16","publish_date":"2009-08-15","title":"씹어 먹는 C 언어 - <10. 연예인 캐스팅(?) (C 언어에서의 형 변환)>"},"18":{"cat_title":"11 - 1. C 언어의 아파트 (배열), 상수","chapter":"C 언어의 아파트 - 배열","next_page":"20","path":"/C","prev_page":"17","publish_date":"2009-11-14","title":"씹어먹는 C 언어 - <11 - 1. C 언어의 아파트 (배열), 상수>"},"19":{"cat_title":"2 - 2. 주석(Comment)에 대한 이해","next_page":"21","path":"/C","prev_page":"6","publish_date":"2009-09-24","tex_title":"주석(Comment)","title":"씹어먹는 C 언어 - <2 - 2. 주석(Comment)에 대한 이해>"},"20":{"cat_title":"11 - 2. C 언어의 아파트2 (고차원의 배열)","next_page":"23","path":"/C","prev_page":"18","publish_date":"2009-10-29","tex_title":"다차원 배열","title":"씹어먹는 C 언어 - <11 - 2. C 언어의 아파트2 (고차원의 배열)>"},"21":{"cat_title":"2 - 3. 수를 표현하는 방법(기수법)","next_page":"7","path":"/C","prev_page":"19","publish_date":"2009-10-12","tex_title":"컴퓨터에서 수를 표현하는 방법","title":"씹어먹는 C 언어 - <2 - 3. 수를 표현하는 방법(기수법)>"},"23":{"cat_title":"12 - 1. 포인터는 영희이다! (포인터)","chapter":"포인터","next_page":"24","path":"/C","prev_page":"20","publish_date":"2009-11-09","title":"씹어먹는 C 언어 - <12 - 1. 포인터는 영희이다! (포인터)>"},"24":{"cat_title":"12 - 2. 포인터는 영희이다! (포인터)","next_page":"25","path":"/C","prev_page":"23","publish_date":"2009-11-14","tex_title":"상수 포인터, 포인터의 덧셈 뺄셈, 배열과 포인터","title":"씹어먹는 C 언어 - <12 - 2. 포인터는 영희이다! (포인터)>"},"25":{"cat_title":"12 - 3. 포인터는 영희이다! (포인터)","next_page":"26","path":"/C","prev_page":"24","publish_date":"2009-11-26","tex_title":"포인터의 포인터","title":"씹어먹는 C 언어 - <12 - 3. 포인터는 영희이다! (포인터)>"},"26":{"cat_title":"13 - 1. 마술 상자 함수(function)","chapter":"함수 (function)","next_page":"27","path":"/C","prev_page":"25","publish_date":"2009-12-14","title":"씹어먹는 C 언어 - <13 - 1. 마술 상자 함수(function)>"},"27":{"cat_title":"13 - 2. 마술 상자 함수 2 (function)","next_page":"28","path":"/C","prev_page":"26","publish_date":"2009-12-19","tex_title":"포인터로 받는 인자","title":"씹어먹는 C 언어 - <13 - 2. 마술 상자 함수 2 (function)>"},"28":{"cat_title":"13 - 3. 마술 상자 함수 3 (function)","next_page":"30","path":"/C","prev_page":"27","publish_date":"2009-12-22","tex_title":"여러가지 인자들","title":"씹어먹는 C 언어 - <13 - 3. 마술 상자 함수 3 (function)>"},"29":{"cat_title":"15 - 1. 일로와봐, 문자열(string)","chapter":"문자열 (string)","next_page":"32","path":"/C","prev_page":"31","publish_date":"2009-12-29","title":"씹어먹는 C 언어 - <15 - 1. 일로와봐, 문자열(string)>"},"30":{"cat_title":"13 - 4. 마술 상자 함수 (생각해볼 문제에 대한 아이디어)","next_page":"31","path":"/C","prev_page":"28","publish_date":"2009-12-27","tex_title":"생각해볼 문제에 대한 아이디어","title":"씹어먹는 C 언어 - <13 - 4. 마술 상자 함수 (생각해볼 문제에 대한 아이디어)>"},"31":{"cat_title":"14. 컴퓨터의 머리로 따라가보자 - 디버깅(debugging)","chapter":"디버깅(Debugging)","next_page":"29","path":"/C","prev_page":"30","publish_date":"2009-12-29","title":"씹어먹는 C 언어 - <14. 컴퓨터의 머리로 따라가보자 - 디버깅(debugging)>"},"32":{"cat_title":"15 - 2. 일로와봐, 문자열(string) - 버퍼에 관한 이해","next_page":"33","path":"/C","prev_page":"29","publish_date":"2010-01-25","tex_title":"버퍼에 대한 이해","title":"씹어먹는 C 언어 - <15 - 2. 일로와봐, 문자열(string) - 버퍼에 관한 이해>"},"33":{"cat_title":"15 - 3. 일로와봐, 문자열(string) - 문자열 지지고 볶기 & 리터럴","next_page":"43","path":"/C","prev_page":"32","publish_date":"2010-02-01","tex_title":"문자열 리터럴에 대한 이해","title":"씹어먹는 C 언어 - <15 - 3. 일로와봐, 문자열(string) - 문자열 지지고 볶기 & 리터럴>"},"34":{"cat_title":"stdio.h (cstdio)","path":"/C Reference/stdio.h","publish_date":"2010-01-25","ref_title":"<stdio.h>, <cstdio>, stdio.h, cstdio","title":"C 언어 레퍼런스 - stdio.h (cstdio) 헤더파일"},"35":{"cat_title":"printf","path":"/C Reference/stdio.h","publish_date":"2010-11-27","ref_title":"printf","title":"C 언어 레퍼런스 - printf 함수"},"36":{"cat_title":"scanf","path":"/C Reference/stdio.h","publish_date":"2010-02-03","ref_title":"scanf","title":"C 언어 레퍼런스 - scanf 함수"},"37":{"cat_title":"fgetc","path":"/C Reference/stdio.h","publish_date":"2010-01-28","ref_title":"fgetc","title":"C 언어 레퍼런스 - fgetc 함수"},"38":{"cat_title":"fgets","path":"/C Reference/stdio.h","publish_date":"2010-01-28","ref_title":"fgets","title":"C 언어 레퍼런스 - fgets 함수"},"39":{"cat_title":"fputc","path":"/C Reference/stdio.h","publish_date":"2010-01-29","ref_title":"fputc","title":"C 언어 레퍼런스 - fputc 함수"},"40":{"cat_title":"fputs","path":"/C Reference/stdio.h","publish_date":"2010-02-02","ref_title":"fputs","title":"C 언어 레퍼런스 - fputs 함수"},"41":{"cat_title":"getc","path":"/C Reference/stdio.h","publish_date":"2010-02-02","ref_title":"getc","title":"C 언어 레퍼런스 - getc 함수"},"43":{"cat_title":"15 - 4. 일로와봐, 문자열(string) - 도서 관리 프로젝트","next_page":"55","path":"/C","prev_page":"33","publish_date":"2010-02-08","tex_title":"도서 관리 프로젝트","title":"씹어먹는 C 언어 - <15 - 4. 일로와봐, 문자열(string) - 도서 관리 프로젝트>"},"44":{"cat_title":"getchar","path":"/C Reference/stdio.h","publish_date":"2010-02-03","ref_title":"getchar","title":"C 언어 레퍼런스 - getchar 함수"},"45":{"cat_title":"gets","path":"/C Reference/stdio.h","publish_date":"2010-02-03","ref_title":"gets","title":"C 언어 레퍼런스 - gets 함수"},"46":{"cat_title":"putc","path":"/C Reference/stdio.h","publish_date":"2010-02-04","ref_title":"putc","title":"C 언어 레퍼런스 - putc 함수"},"47":{"cat_title":"putchar","path":"/C Reference/stdio.h","publish_date":"2010-02-04","ref_title":"putchar","title":"C 언어 레퍼런스 - putchar 함수"},"48":{"cat_title":"puts","path":"/C Reference/stdio.h","publish_date":"2010-02-04","ref_title":"puts","title":"C 언어 레퍼런스 - puts 함수"},"49":{"cat_title":"ungetc","path":"/C Reference/stdio.h","publish_date":"2010-02-04","ref_title":"ungetc","title":"C 언어 레퍼런스 - ungetc 함수"},"50":{"cat_title":"clearerr","path":"/C Reference/stdio.h","publish_date":"2010-02-05","ref_title":"clearerr","title":"C 언어 레퍼런스 - clearerr 함수"},"51":{"cat_title":"feof","path":"/C Reference/stdio.h","publish_date":"2010-02-05","ref_title":"feof","title":"C 언어 레퍼런스 - feof 함수"},"52":{"cat_title":"ferror","path":"/C Reference/stdio.h","publish_date":"2010-02-05","ref_title":"ferror","title":"C 언어 레퍼런스 - ferror 함수"},"53":{"cat_title":"perror","path":"/C Reference/stdio.h","publish_date":"2010-02-08","ref_title":"perror","title":"C 언어 레퍼런스 - perror 함수"},"54":{"cat_title":"fclose","path":"/C Reference/stdio.h","publish_date":"2010-02-08","ref_title":"fclose","title":"C 언어 레퍼런스 - fclose 함수"},"55":{"cat_title":"16 - 1. 모아 모아 구조체(struct)","chapter":"구조체 (struct)","next_page":"60","path":"/C","prev_page":"43","publish_date":"2010-02-14","title":"씹어먹는 C 언어 - <16 - 1. 모아 모아 구조체(struct)>"},"57":{"cat_title":"fflush","path":"/C Reference/stdio.h","publish_date":"2010-02-10","ref_title":"fflush","title":"C 언어 레퍼런스 - fflush 함수"},"58":{"cat_title":"fopen","path":"/C Reference/stdio.h","publish_date":"2010-02-11","ref_title":"fopen","title":"C 언어 레퍼런스 - fopen 함수"},"59":{"cat_title":"freopen","path":"/C Reference/stdio.h","publish_date":"2010-02-13","ref_title":"freopen","title":"C 언어 레퍼런스 - freopen 함수"},"60":{"cat_title":"16 - 2. 모아 모아 구조체(struct) - 구조체 인자로 가진 함수","next_page":"71","path":"/C","prev_page":"55","publish_date":"2010-04-11","tex_title":"구조체를 인자로 받는 함수","title":"씹어먹는 C 언어 - <16 - 2. 모아 모아 구조체(struct) - 구조체 인자로 가진 함수>"},"61":{"cat_title":"setbuf","path":"/C Reference/stdio.h","publish_date":"2010-02-16","ref_title":"setbuf","title":"C 언어 레퍼런스 - setbuf 함수"},"62":{"cat_title":"setvbuf","path":"/C Reference/stdio.h","publish_date":"2010-02-18","ref_title":"setvbuf","title":"C 언어 레퍼런스 - setvbuf 함수"},"64":{"cat_title":"fprintf","path":"/C Reference/stdio.h","publish_date":"2010-02-19","ref_title":"fprintf","title":"C 언어 레퍼런스 - fprintf 함수"},"65":{"cat_title":"fscanf","path":"/C Reference/stdio.h","publish_date":"2010-02-22","ref_title":"fscanf","title":"C 언어 레퍼런스 - fscanf 함수"},"66":{"cat_title":"sprintf","path":"/C Reference/stdio.h","publish_date":"2010-02-22","ref_title":"sprintf","title":"C 언어 레퍼런스 - sprintf 함수"},"67":{"cat_title":"sscanf","path":"/C Reference/stdio.h","publish_date":"2011-01-03","ref_title":"sscanf","title":"C 언어 레퍼런스 - sscanf 함수"},"68":{"cat_title":"fread","path":"/C Reference/stdio.h","publish_date":"2010-03-21","ref_title":"fread","title":"C 언어 레퍼런스 - fread 함수"},"69":{"cat_title":"fwrite","path":"/C Reference/stdio.h","publish_date":"2010-04-11","ref_title":"fwrite","title":"C 언어 레퍼런스 - fwrite 함수"},"70":{"cat_title":"fgetpos","path":"/C Reference/stdio.h","publish_date":"2010-04-18","ref_title":"fgetpos","title":"C 언어 레퍼런스 - fgetpos 함수"},"71":{"cat_title":"16 - 3. 구조체와 친구들(공용체(union), 열거형(enum)","next_page":"83","path":"/C","prev_page":"60","publish_date":"2010-06-13","tex_title":"공용체(union)와 열거형(enum)","title":"씹어먹는 C 언어 - <16 - 3. 구조체와 친구들(공용체(union), 열거형(enum))>"},"72":{"cat_title":"fseek","path":"/C Reference/stdio.h","publish_date":"2010-04-24","ref_title":"fseek","title":"C 언어 레퍼런스 - fseek 함수"},"73":{"cat_title":"fsetpos","path":"/C Reference/stdio.h","publish_date":"2010-04-24","ref_title":"fsetpos","title":"C 언어 레퍼런스 - fsetpos 함수"},"74":{"cat_title":"ftell","path":"/C Reference/stdio.h","publish_date":"2010-04-24","ref_title":"ftell","title":"C 언어 레퍼런스 - ftell 함수"},"75":{"cat_title":"rewind","path":"/C Reference/stdio.h","publish_date":"2010-04-24","ref_title":"rewind","title":"C 언어 레퍼런스 - rewind 함수"},"76":{"cat_title":"string.h (cstring)","path":"/C Reference/string.h","publish_date":"2010-04-24","ref_title":"<string.h>, <cstring>, string.h, cstring","title":"C 언어 레퍼런스 - string.h (cstring) 헤더파일"},"77":{"cat_title":"memcpy","path":"/C Reference/string.h","publish_date":"2010-04-24","ref_title":"memcpy","title":"C 언어 레퍼런스 - memcpy 함수"},"78":{"cat_title":"memmove","path":"/C Reference/string.h","publish_date":"2010-04-25","ref_title":"memmove","title":"C 언어 레퍼런스 - memmove 함수"},"79":{"cat_title":"strcpy","path":"/C Reference/string.h","publish_date":"2010-05-02","ref_title":"strcpy","title":"C 언어 레퍼런스 - strcpy 함수"},"80":{"cat_title":"strncpy","path":"/C Reference/string.h","publish_date":"2010-05-09","ref_title":"strncpy","title":"C 언어 레퍼런스 - strncpy 함수"},"81":{"cat_title":"strcat","path":"/C Reference/string.h","publish_date":"2010-05-21","ref_title":"strcat","title":"C 언어 레퍼런스 - strcat 함수"},"82":{"cat_title":"strncat","path":"/C Reference/string.h","publish_date":"2010-05-23","ref_title":"strncat","title":"C 언어 레퍼런스 - strncat 함수"},"83":{"cat_title":"17. 변수의 생존 조건 및 데이터 세그먼트의 구조","chapter":"변수의 생존 조건과 데이터 세그먼트의 구조","next_page":"87","path":"/C","prev_page":"71","publish_date":"2010-06-19","title":"씹어먹는 C 언어 - <17. 변수의 생존 조건 및 데이터 세그먼트의 구조>"},"84":{"cat_title":"memcmp","path":"/C Reference/string.h","publish_date":"2010-06-25","ref_title":"memcmp","title":"C 언어 레퍼런스 - memcmp 함수"},"85":{"cat_title":"strcmp","path":"/C Reference/string.h","publish_date":"2010-06-25","ref_title":"strcmp","title":"C 언어 레퍼런스 - strcmp 함수"},"86":{"cat_title":"strcoll","path":"/C Reference/string.h","publish_date":"2010-07-10","ref_title":"strcoll","title":"C 언어 레퍼런스- strcoll 함수"},"87":{"cat_title":"18 - 1. 파일 뽀개기 (헤더파일과 #include)","chapter":"여러 파일로 나누기","next_page":"88","path":"/C","prev_page":"83","publish_date":"2010-07-16","title":"씹어먹는 C 언어 - <18 - 1. 파일 뽀개기 (헤더파일과 #include) >"},"88":{"cat_title":"18 - 2. 파일 뽀개기 (# 친구들, 라이브러리)","next_page":"89","path":"/C","prev_page":"87","publish_date":"2010-07-20","tex_title":"여러 전처리기 구문과 라이브러리 사용법","title":"씹어먹는 C 언어 - <18 - 2. 파일 뽀개기 (# 친구들, 라이브러리)>"},"89":{"cat_title":"19. main 함수의 인자, 텅 빈 void 형","chapter":"void 타입과 main 함수에 대한 이해","next_page":"98","path":"/C","prev_page":"88","publish_date":"2010-08-02","title":"씹어먹는 C 언어 - <19. main 함수의 인자, 텅 빈 void 형>"},"90":{"cat_title":"strncmp","path":"/C Reference/string.h","publish_date":"2010-08-01","ref_title":"strncmp","title":"C 언어 레퍼런스 - strncmp 함수"},"91":{"cat_title":"strxfrm","path":"/C Reference/string.h","publish_date":"2010-08-01","ref_title":"strxfrm","title":"C 언어 레퍼런스 - strxfrm 함수"},"92":{"cat_title":"memchr","path":"/C Reference/string.h","publish_date":"2010-08-01","ref_title":"memchr","title":"C 언어 레퍼런스 - memchr 함수"},"93":{"cat_title":"strchr","path":"/C Reference/string.h","publish_date":"2010-08-02","ref_title":"strchr","title":"C 언어 레퍼런스 - strchr 함수"},"94":{"cat_title":"strcspn","path":"/C Reference/string.h","publish_date":"2010-08-02","ref_title":"strcspn","title":"C 언어 레퍼런스 - strcspn 함수"},"95":{"cat_title":"strpbrk","path":"/C Reference/string.h","publish_date":"2010-08-02","ref_title":"strpbrk","title":"C 언어 레퍼런스 - strpbrk 함수"},"96":{"cat_title":"strrchr","path":"/C Reference/string.h","publish_date":"2010-08-02","ref_title":"strrchr","title":"C 언어 레퍼런스 - strrchr 함수"},"97":{"cat_title":"strspn","path":"/C Reference/string.h","publish_date":"2010-11-21","ref_title":"strspn","title":"C 언어 레퍼런스 - strspn 함수"},"98":{"cat_title":"20 - 1. 동동동 메모리 동적할당(Dynamic Memory Allocation)","chapter":"동적 메모리 할당 (dynamic memory allocation)","next_page":"100","path":"/C","prev_page":"89","publish_date":"2010-08-03","title":"씹어먹는 C 언어 - <20 - 1. 동동동 메모리 동적할당(Dynamic Memory Allocation)>"},"99":{"cat_title":"21. 매크로 함수, 인라인 함수","chapter":"매크로 함수, 인라인 함수","next_page":"103","path":"/C","prev_page":"100","publish_date":"2010-11-21","title":"씹어먹는 C 언어 - <21. 매크로 함수, 인라인 함수>"},"100":{"cat_title":"20 - 2. 메모리 동적할당 + 메모리 갖고 놀기","next_page":"99","path":"/C","prev_page":"98","publish_date":"2010-09-13","tex_title":"구조체의 동적 할당과 메모리 관리 함수","title":"씹어먹는 C 언어 - <20 - 2. 메모리 동적할당 + 메모리 갖고 놀기>"},"101":{"cat_title":"strstr","path":"/C Reference/string.h","publish_date":"2010-11-27","ref_title":"strstr","title":"C 언어 레퍼런스 - strstr 함수"},"102":{"cat_title":"strtok","path":"/C Reference/string.h","publish_date":"2010-11-27","ref_title":"strtok","title":"C 언어 레퍼런스 - strtok 함수"},"103":{"cat_title":"22. C 언어의 잡다한 키워드들 (typedef, volatile, #pragma)","chapter":"그 밖에 키워드들","next_page":"117","path":"/C","prev_page":"99","publish_date":"2010-12-25","title":"씹어먹는 C 언어 - <22. C 언어의 잡다한 키워드들 (typedef, volatile, #pragma)>"},"104":{"cat_title":"memset","path":"/C Reference/string.h","publish_date":"2010-11-28","ref_title":"memset","title":"C 언어 레퍼런스 - memset 함수"},"105":{"cat_title":"strerror","path":"/C Reference/string.h","publish_date":"2010-12-12","ref_title":"strerror","title":"C 언어 레퍼런스 - strerror 함수"},"106":{"cat_title":"strlen","path":"/C Reference/string.h","publish_date":"2010-12-12","ref_title":"strlen","title":"C 언어 레퍼런스 - strlen 함수"},"108":{"cat_title":"time.h","path":"/C Reference/time.h","publish_date":"2010-12-25","ref_title":"<time.h>","title":"C 언어 레퍼런스 - time.h 헤더파일"},"109":{"cat_title":"struct tm","path":"/C Reference/time.h","publish_date":"2010-12-25","ref_title":"tm 구조체, tm, struct tm","title":"C 언어 레퍼런스 - struct tm ( tm 구조체 )"},"110":{"cat_title":"clock","path":"/C Reference/time.h","publish_date":"2010-12-25","ref_title":"clock","title":"C 언어 레퍼런스 - clock 함수"},"111":{"cat_title":"difftime","path":"/C Reference/time.h","publish_date":"2010-12-25","ref_title":"difftime","title":"C 언어 레퍼런스 - difftime 함수"},"112":{"cat_title":"mktime","path":"/C Reference/time.h","publish_date":"2010-12-26","ref_title":"mktime","title":"C 언어 레퍼런스 - mktime 함수"},"113":{"cat_title":"time_t 형","path":"/C Reference/time.h","publish_date":"2010-12-25","ref_title":"time_t","title":"C 언어 레퍼런스 - time_t 형"},"114":{"cat_title":"time","path":"/C Reference/time.h","publish_date":"2010-12-26","ref_title":"time","title":"C 언어 레퍼런스 - time 함수"},"115":{"path":"/잡담","publish_date":"2010-12-28","title":"100 번째 글을 돌파하며"},"116":{"cat_title":"asctime","path":"/C Reference/time.h","publish_date":"2010-12-26","ref_title":"asctime","title":"C 언어 레퍼런스 - asctime 함수"},"117":{"cat_title":"23 - 1. 파일 하고 이야기 하기 (파일 입출력에 대한 기본적 이해)","chapter":"파일 입출력","next_page":"123","path":"/C","prev_page":"103","publish_date":"2010-12-28","title":"씹어먹는 C 언어 - <23 - 1. 파일 하고 이야기 하기 (파일 입출력에 대한 기본적 이해)>"},"118":{"cat_title":"ctime","path":"/C Reference/time.h","publish_date":"2010-12-29","ref_title":"ctime","title":"C 언어 레퍼런스 - ctime 함수"},"119":{"cat_title":"gmtime","path":"/C Reference/time.h","publish_date":"2010-12-29","ref_title":"gmtime","title":"C 언어 레퍼런스 - gmtime 함수"},"120":{"cat_title":"localtime","path":"/C Reference/time.h","publish_date":"2010-12-30","ref_title":"localtime","title":"C 언어 레퍼런스 - localtime 함수"},"121":{"cat_title":"stdlib.h (cstdlib)","path":"/C Reference/stdlib.h","publish_date":"2011-01-05","ref_title":"<stdlib.h>, cstdlib","title":"C 언어 레퍼런스 - stdlib.h (cstdlib)"},"122":{"cat_title":"strftime","path":"/C Reference/time.h","publish_date":"2011-01-05","ref_title":"strftime","title":"C 언어 레퍼런스 - strftime 함수"},"123":{"cat_title":"23 - 2. 파일 하고 이야기 하기 (파일 입출력)","next_page":"125","path":"/C","prev_page":"117","publish_date":"2011-01-10","tex_title":"파일 안에서 이동하기","title":"씹어먹는 C 언어 - <23 - 2. 파일 하고 이야기 하기 (파일 입출력)>"},"124":{"cat_title":"atof","path":"/C Reference/stdlib.h","publish_date":"2011-01-09","ref_title":"atof","title":"C 언어 레퍼런스 - atof 함수"},"125":{"cat_title":"23 - 3. 파일 하고 이야기 하기 (파일 입출력 - 마무리)","next_page":"129","path":"/C","prev_page":"123","publish_date":"2011-01-17","tex_title":"도서 관리 프로그램의 완성","title":"씹어먹는 C 언어 - <23 - 3. 파일 하고 이야기 하기 (파일 입출력 - 마무리)>"},"129":{"cat_title":"24. 더 빠르게 실행되는 코드를 위하여 (C 코드 최적화)","chapter":"C 코드 최적화","next_page":"130","path":"/C","prev_page":"125","publish_date":"2011-01-18","title":"씹어먹는 C 언어 - <24. 더 빠르게 실행되는 코드를 위하여 (C 코드 최적화)>"},"130":{"path":"/C","prev_page":"129","publish_date":"2011-01-20","title":"초보자를 위한 C 언어 강좌 - 씹어먹는 C 언어 (완결)"},"131":{"cat_title":"atoi","path":"/C Reference/stdlib.h","publish_date":"2011-01-27","ref_title":"atoi","title":"C 언어 레퍼런스 - atoi 함수"},"132":{"cat_title":"atol","path":"/C Reference/stdlib.h","publish_date":"2011-01-27","ref_title":"atol","title":"C 언어 레퍼런스 - atol 함수"},"134":{"cat_title":"1. 자~ C++ 의 세계로","chapter":"C++ 시작하기","next_page":"136","path":"/C++","prev_page":"135","publish_date":"2011-03-06","title":"씹어먹는 C++ - <1. 자~ C++ 의 세계로>"},"135":{"chapter":"C++ 을 시작하기에 앞서","next_page":"134","path":"/C++","publish_date":"2011-03-05","title":"씹어먹는 C++ 강좌 계획"},"136":{"cat_title":"1 - 2. 첫 C++ 프로그램 분석하기","next_page":"138","path":"/C++","prev_page":"134","publish_date":"2011-03-06","tex_title":"첫 C++ 프로그램 분석하기","title":"씹어먹는 C++ - <1 - 2. 첫 C++ 프로그램 분석하기>"},"138":{"cat_title":"1 - 3. C++ 은 C 친구 - C 와 공통점","next_page":"141","path":"/C++","prev_page":"136","publish_date":"2011-05-15","tex_title":"C++ 와 C 언어의 공통 문법 구조","title":"씹어먹는 C++ - <1 - 3. C++ 은 C 친구 - C 와 공통점>"},"139":{"cat_title":"rand","path":"/C Reference/stdlib.h","publish_date":"2011-05-05","ref_title":"rand","title":"C 언어 레퍼런스 - rand 함수"},"140":{"cat_title":"srand","path":"/C Reference/stdlib.h","publish_date":"2011-05-05","ref_title":"srand","title":"C 언어 레퍼런스 - srand 함수"},"141":{"cat_title":"2. C++ 참조자(레퍼런스)의 도입","chapter":"C++ 의 참조자 (레퍼런스)","next_page":"169","path":"/C++","prev_page":"138","publish_date":"2012-01-01","title":"씹어먹는 C++ - <2. C++ 참조자(레퍼런스)의 도입>"},"142":{"path":"/잡담","publish_date":"2011-08-16","title":"비주얼 스튜디오에서 소스 한꺼번에 정렬하기"},"143":{"path":"/C++ Reference/iostream","publish_date":"2011-08-17","ref_title":"iostream, <iostream>","title":"C++ IOstream (입출력) 라이브러리"},"144":{"cat_title":"ios_base 클래스","path":"/C++ Reference/iostream","publish_date":"2011-08-17","ref_title":"ios_base","title":"C++ 레퍼런스 - ios_base 클래스"},"145":{"cat_title":"ios 클래스","path":"/C++ Reference/iostream","publish_date":"2011-08-17","ref_title":"ios, <ios>","title":"C++ 레퍼런스 - ios 클래스"},"146":{"cat_title":"istream 클래스","path":"/C++ Reference/iostream","publish_date":"2011-08-17","ref_title":"istream, <istream>, std::basic_istream, basic_istream","title":"C++ 레퍼런스 - istream 클래스"},"147":{"cat_title":"istream::operator>> (추출 연산자)","path":"/C++ Reference/iostream","publish_date":"2011-08-17","ref_title":"istream::operator>>","title":"C++ 레퍼런스 - istream::operator>> (추출 연산자)"},"149":{"cat_title":"istream::getline","path":"/C++ Reference/iostream","publish_date":"2011-08-18","ref_title":"getline","title":"C++ 레퍼런스 - istream::getline 함수"},"150":{"cat_title":"ios::exceptions","path":"/C++ Reference/iostream","publish_date":"2011-08-18","ref_title":"ios::exceptions","title":"C++ 레퍼런스 - ios::exceptions"},"151":{"cat_title":"ifstream 클래스","path":"/C++ Reference/iostream","publish_date":"2011-08-18","ref_title":"ifstream","title":"C++ 레퍼런스 - ifstream 클래스"},"152":{"cat_title":"ios_base::width","path":"/C++ Reference/iostream","publish_date":"2011-08-18","ref_title":"ios_base::width, width","title":"C++ 레퍼런스 - ios_base::width"},"153":{"cat_title":"ios_base::flags","path":"/C++ Reference/iostream","publish_date":"2011-08-19","ref_title":"flags, ios_base::flags","title":"C++ 레퍼런스 - ios_base::flags 함수"},"154":{"cat_title":"ios_base::fmtflags 타입","path":"/C++ Reference/iostream","publish_date":"2011-08-19","ref_title":"ios_base::fmtflags, fmtflags","title":"C++ 레퍼런스 - ios_base::fmtflags 타입"},"155":{"cat_title":"ios_base::setf","path":"/C++ Reference/iostream","publish_date":"2011-08-19","ref_title":"setf","title":"C++ 레퍼런스 - ios_base::setf 함수"},"156":{"cat_title":"ios_base::unsetf","path":"/C++ Reference/iostream","publish_date":"2011-08-19","ref_title":"unsetf, ios_base::unsetf","title":"C++ 레퍼런스 - ios_base::unsetf 함수"},"157":{"cat_title":"ios_base::precision","path":"/C++ Reference/iostream","publish_date":"2011-08-19","ref_title":"precision","title":"C++ 레퍼런스 - ios_base::precision 함수"},"158":{"cat_title":"ios_base::imbue","path":"/C++ Reference/iostream","publish_date":"2011-08-20","ref_title":"imbue, ios_base::imbue","title":"C++ 레퍼런스 - ios_base::imbue"},"159":{"cat_title":"ios_base::register_callback","path":"/C++ Reference/iostream","publish_date":"2011-08-20","ref_title":"ios_base::register_callback, register_callback","title":"C++ 레퍼런스 - ios_base::register_callback 함수"},"160":{"cat_title":"ios_base::getloc","path":"/C++ Reference/iostream","publish_date":"2011-08-20","ref_title":"getloc, ios_base::getloc","title":"C++ 레퍼런스 - ios_base::getloc 함수"},"161":{"cat_title":"ios_base::iword","path":"/C++ Reference/iostream","publish_date":"2011-10-22","ref_title":"ios_base::iword, iword","title":"C++ 레퍼런스 - ios_base::iword"},"162":{"cat_title":"ios_base::xalloc","path":"/C++ Reference/iostream","publish_date":"2011-10-22","ref_title":"xalloc, ios_base::xalloc","title":"C++ 레퍼런스 - ios_base::xalloc 함수"},"163":{"cat_title":"ios_base::pword","path":"/C++ Reference/iostream","publish_date":"2011-10-22","ref_title":"ios_base::pword, pword","title":"C++ 레퍼런스 - ios_base::pword 함수"},"164":{"cat_title":"ios::good","path":"/C++ Reference/iostream","publish_date":"2011-10-23","ref_title":"good, ios::good","title":"C++ 레퍼런스 - ios::good 함수"},"165":{"cat_title":"ios::fail","path":"/C++ Reference/iostream","publish_date":"2011-10-23","ref_title":"fail, ios::fail","title":"C++ 레퍼런스 - ios::fail 함수"},"166":{"cat_title":"ios::bad","path":"/C++ Reference/iostream","publish_date":"2011-10-23","ref_title":"bad, ios::bad","title":"C++ 레퍼런스 - ios::bad 함수"},"167":{"cat_title":"ios::eof","path":"/C++ Reference/iostream","publish_date":"2011-10-23","ref_title":"eof, ios::eof","title":"C++ 레퍼런스 - ios::eof 함수"},"168":{"cat_title":"ios::operator!","path":"/C++ Reference/iostream","publish_date":"2011-10-23","ref_title":"ios::operator!","title":"C++ 레퍼런스 - ios::operator!"},"169":{"cat_title":"3. C++ 의 세계로 오신 것을 환영합니다. (new, delete)","chapter":"C++ 의 세계로","next_page":"172","path":"/C++","prev_page":"141","publish_date":"2012-01-01","title":"씹어먹는 C++ - <3. C++ 의 세계로 오신 것을 환영합니다. (new, delete)>"},"170":{"cat_title":"ios::operator void*","path":"/C++ Reference/iostream","publish_date":"2012-01-01","ref_title":"ios::operator void*","title":"C++ 레퍼런스 - ios::operator void*"},"171":{"cat_title":"ios::rdstate","path":"/C++ Reference/iostream","publish_date":"2012-03-25","ref_title":"rdstate, ios::rdstate","title":"C++ 레퍼런스 - ios::rdstate 함수"},"172":{"cat_title":"4 - 1. 이 세상은 객체로 이루어져 있다","chapter":"객체지향프로그래밍의 시작","next_page":"173","path":"/C++","prev_page":"169","publish_date":"2012-02-29","title":"씹어먹는 C++ - <4 - 1. 이 세상은 객체로 이루어져 있다>"},"173":{"cat_title":"4 - 2. 클래스의 세계로 오신 것을 환영합니다. (함수의 오버로딩, 생성자)","next_page":"188","path":"/C++","prev_page":"172","publish_date":"2012-08-04","tex_title":"생성자와 함수의 오버로딩","title":"씹어먹는 C++ - <4 - 2. 클래스의 세계로 오신 것을 환영합니다. (함수의 오버로딩, 생성자)>"},"174":{"cat_title":"STL 컨테이너 (STL Container)","path":"/C++ Reference/Containers","publish_date":"2012-03-24","title":"C++ 레퍼런스 - STL 컨테이너 (STL Container)"},"175":{"cat_title":"vector","path":"/C++ Reference/Containers/vector","publish_date":"2012-03-24","title":"C++ 레퍼런스 - STL 컨테이너 - vector"},"176":{"cat_title":"deque","path":"/C++ Reference/Containers/deque","publish_date":"2012-03-24","ref_title":"<deque>","title":"C++ 레퍼런스 - STL 컨테이너 - deque"},"177":{"cat_title":"list","path":"/C++ Reference/Containers/list","publish_date":"2012-03-24","title":"C++ 레퍼런스 - STL 컨테이너 - list"},"178":{"cat_title":"vector 생성자","path":"/C++ Reference/Containers/vector","publish_date":"2012-03-25","title":"C++ 레퍼런스 - STL 컨테이너 - vector 생성자"},"179":{"cat_title":"ios::setstate","path":"/C++ Reference/iostream","publish_date":"2012-03-25","ref_title":"setstate, ios::setstate","title":"C++ 레퍼런스 - ios::setstate 함수"},"180":{"cat_title":"ios::clear","path":"/C++ Reference/iostream","publish_date":"2012-03-25","ref_title":"clear, ios::clear","title":"C++ 레퍼런스 - ios::clear"},"181":{"cat_title":"ios::fill","path":"/C++ Reference/iostream","publish_date":"2012-03-25","ref_title":"ios::fill","title":"C++ 레퍼런스 - ios::fill 함수"},"182":{"cat_title":"ios::rdbuf","path":"/C++ Reference/iostream","publish_date":"2012-03-25","ref_title":"ios::rdbuf, rdbuf","title":"C++ 레퍼런스 - ios::rdbuf 함수"},"183":{"cat_title":"vector::assign","path":"/C++ Reference/Containers/vector","publish_date":"2012-03-25","ref_title":"assign","title":"C++ 레퍼런스 - STL 컨테이너 - vector::assign 함수"},"184":{"path":"/C","publish_date":"2012-03-25","title":"씹어먹는 C 언어 - 찾아보기"},"185":{"cat_title":"vector::push_back","path":"/C++ Reference/Containers/vector","publish_date":"2012-08-05","ref_title":"push_back","title":"C++ 레퍼런스 - vector::push_back"},"186":{"cat_title":"vector::insert","path":"/C++ Reference/Containers/vector","publish_date":"2012-08-05","ref_title":"insert","title":"C++ 레퍼런스 - vector::insert"},"187":{"cat_title":"씹어먹는 C 언어 강좌 - PDF 파일","path":"/C","publish_date":"2012-08-06","title":"씹어먹는 C 언어 강좌 - PDF 파일 (2020 업데이트)"},"188":{"cat_title":"4 - 3. 스타크래프트를 만들자 ① (복사 생성자, 소멸자)","next_page":"197","path":"/C++","prev_page":"173","publish_date":"2013-01-06","tex_title":"복사 생성자와 소멸자","title":"씹어먹는 C++ - <4 - 3. 스타크래프트를 만들자 ① (복사 생성자, 소멸자)>"},"189":{"path":"/C++","publish_date":"2012-11-03","title":"씹어먹는 C++ 토막글 ① - Rvalue(우측값) 레퍼런스에 관해"},"190":{"cat_title":"ios::tie","path":"/C++ Reference/iostream","publish_date":"2012-11-07","ref_title":"ios::tie, tie","title":"C++ 레퍼런스 - ios::tie 함수"},"191":{"cat_title":"istream::get","path":"/C++ Reference/iostream","publish_date":"2012-11-07","ref_title":"get","title":"C++ 레퍼런스 - istream::get 함수"},"192":{"cat_title":"istream::gcount","path":"/C++ Reference/iostream","publish_date":"2012-11-07","ref_title":"gcount","title":"C++ 레퍼런스 - istream::gcount 함수"},"193":{"cat_title":"istream::ignore","path":"/C++ Reference/iostream","publish_date":"2012-11-07","ref_title":"ignore","title":"C++ 레퍼런스 - istream::ignore 함수"},"194":{"cat_title":"istream::peek","path":"/C++ Reference/iostream","publish_date":"2012-11-09","ref_title":"peek","title":"C++ 레퍼런스 - istream::peek 함수"},"195":{"path":"/C++","publish_date":"2013-01-05","title":"비주얼 스튜디오 2010 에서 C 및 C++ 프로그래밍 하기"},"196":{"path":"/C++","publish_date":"2013-01-08","title":"씹어먹는 C++ 토막글 ② - 람다(lambda) 함수"},"197":{"cat_title":"4 - 4. 스타크래프트를 만들자 ② (const, static)","next_page":"198","path":"/C++","prev_page":"188","publish_date":"2013-05-26","tex_title":"const, const, const!","title":"씹어먹는 C++ - <4 - 4. 스타크래프트를 만들자 ② (const, static)>"},"198":{"cat_title":"4 - 5. 내가 만드는 String 클래스","next_page":"253","path":"/C++","prev_page":"197","publish_date":"2013-08-15","tex_title":"내가 만들어보는 문자열 클래스","title":"씹어먹는 C++ - <4 - 5. 내가 만드는 String 클래스>"},"199":{"path":"/프로그래밍","publish_date":"2013-08-04","title":"모든 컴퓨터 과학자가 알아야 할 부동 소수점의 모든 것(What Every Computer Scientists Should Know About Floating Point Arithmetic)"},"201":{"path":"/프로그래밍","publish_date":"2013-08-04","title":"오픈북 프로젝트 - 양질의 컴퓨터 문서 공급 프로젝트"},"202":{"cat_title":"5 - 1. 내가 만든 연산자 - 연산자 오버로딩","chapter":"연산자 오버로딩(overloading)","next_page":"203","path":"/C++","prev_page":"253","publish_date":"2013-08-25","title":"씹어먹는 C++ - <5 - 1. 내가 만든 연산자 - 연산자 오버로딩>"},"203":{"cat_title":"5 - 2. 입출력, 첨자, 타입변환, 증감 연산자 오버로딩","next_page":"204","path":"/C++","prev_page":"202","publish_date":"2013-08-29","tex_title":"잡다한 연산자들의 오버로딩","title":"씹어먹는 C++ - <5 - 2. 입출력, 첨자, 타입변환, 증감 연산자 오버로딩>"},"204":{"cat_title":"5 - 3. 연산자 오버로딩 프로젝트 - N 차원 배열","next_page":"209","path":"/C++","prev_page":"203","publish_date":"2013-09-04","tex_title":"N 차원 배열 만들기 프로젝트","title":"씹어먹는 C++ - <5 - 3. 연산자 오버로딩 프로젝트 - N 차원 배열>"},"208":{"path":"/C++","publish_date":"2013-10-02","title":"C++ 11 자주 질문되는 것들 모음 (C++ 11 FAQs - Bjarne Stroustup)"},"209":{"cat_title":"6 - 1. C++ 표준 문자열 & 부모의 것을 물려쓰자 - 상속","chapter":"클래스의 상속","next_page":"210","path":"/C++","prev_page":"204","publish_date":"2014-03-30","title":"씹어먹는 C++ - <6 - 1. C++ 표준 문자열 & 부모의 것을 물려쓰자 - 상속>"},"210":{"cat_title":"6 - 2. 가상(virtual) 함수와 다형성","next_page":"211","path":"/C++","prev_page":"209","publish_date":"2014-03-31","tex_title":"가상 함수와 다형성","title":"씹어먹는 C++ - <6 - 2. 가상(virtual) 함수와 다형성>"},"211":{"cat_title":"6 - 3. 가상함수와 상속에 관련한 잡다한 내용들","next_page":"213","path":"/C++","prev_page":"210","publish_date":"2014-04-13","tex_title":"상속에 관련된 잡다한 내용들","title":"씹어먹는 C++ - <6 - 3. 가상함수와 상속에 관련한 잡다한 내용들>"},"213":{"cat_title":"7 - 1. C++ 에서의 입출력 (istream, ostream)","chapter":"C++ 표준 입출력 라이브러리","next_page":"215","path":"/C++","prev_page":"211","publish_date":"2015-05-04","title":"씹어먹는 C++ - <7 - 1. C++ 에서의 입출력 (istream, ostream)>"},"214":{"path":"/C","publish_date":"2015-08-11","title":"C 언어 및 강좌 관련 자주 질문되는 것들에 대한 답변"},"215":{"cat_title":"7 - 2. C++ 에서 파일 입출력 - std::ifstream. std::ofstream, std::stringstream","next_page":"217","path":"/C++","prev_page":"213","publish_date":"2016-07-14","tex_title":"C++ 파일 입출력","title":"씹어먹는 C++ - <7 - 2. C++ 에서 파일 입출력 - std::ifstream. std::ofstream, std::stringstream>"},"217":{"cat_title":"8 - 1. Excel 만들기 프로젝트 1부","chapter":"엑셀 만들기 프로젝트","next_page":"218","path":"/C++","prev_page":"215","publish_date":"2016-07-18","title":"씹어먹는 C++ - <8 - 1. Excel 만들기 프로젝트 1부>"},"218":{"cat_title":"8 - 2. Excel 만들기 프로젝트 2부","next_page":"219","path":"/C++","prev_page":"217","publish_date":"2016-07-19","tex_title":"엑셀 만들기 프로젝트 2부","title":"씹어먹는 C++ - <8 - 2. Excel 만들기 프로젝트 2부>"},"219":{"cat_title":"9 - 1. 코드를 찍어내는 틀 - C++ 템플릿(template)","chapter":"C++ 템플릿","next_page":"290","path":"/C++","prev_page":"218","publish_date":"2017-04-07","title":"씹어먹는 C++ - <9 - 1. 코드를 찍어내는 틀 - C++ 템플릿(template)>"},"220":{"cat_title":"비주얼 스튜디오 2017 커뮤니티에서 C/C++ 프로그래밍 하기","path":"/C++","publish_date":"2017-03-30","title":"비주얼 스튜디오 2017 커뮤니티에서 C/C++ 프로그래밍 하기"},"221":{"cat_title":"9 - 3. 템플릿 메타 프로그래밍 (Template Meta programming)","next_page":"222","path":"/C++","prev_page":"290","publish_date":"2017-06-26","tex_title":"템플릿 메타프로그래밍 1 부","title":"씹어먹는 C++ - <9 - 3. 템플릿 메타 프로그래밍 (Template Meta programming)>"},"222":{"cat_title":"9 - 4. 템플릿 메타 프로그래밍 2","next_page":"223","path":"/C++","prev_page":"221","publish_date":"2017-07-02","tex_title":"템플릿 메타프로그래밍 2 부","title":"씹어먹는 C++ - <9 - 4. 템플릿 메타 프로그래밍 2>"},"223":{"cat_title":"10 - 1. C++ STL - 벡터(std::vector), 리스트(list), 데크(deque)","chapter":"C++ 표준 라이브러리 (컨테이너와 알고리즘)","next_page":"224","path":"/C++","prev_page":"222","publish_date":"2017-07-04","tex_title":"C++ 표준 컨테이너","title":"씹어먹는 C++ - <10 - 1. C++ STL - 벡터(std::vector), 리스트(list), 데크(deque)>"},"224":{"cat_title":"10 - 2. C++ STL - 셋(set), 맵(map), unordered_set, unordered_map","next_page":"225","path":"/C++","prev_page":"223","publish_date":"2017-07-08","tex_title":"C++ 의 표준 연관 컨테이너들","title":"씹어먹는 C++ - <10 - 2. C++ STL - 셋(set), 맵(map), unordered_set, unordered_map>"},"225":{"cat_title":"10 - 3. C++ STL - 알고리즘(algorithm)","next_page":"292","path":"/C++","prev_page":"224","publish_date":"2017-07-09","tex_title":"C++ 표준 알고리즘 라이브러리","title":"씹어먹는 C++ - <10 - 3. C++ STL - 알고리즘(algorithm)>"},"227":{"cat_title":"12 - 1. 우측값 레퍼런스와 이동 생성자","chapter":"우측값과 이동 연산","next_page":"228","path":"/C++","prev_page":"230","publish_date":"2018-03-24","tex_title":"우측값 레퍼런스와 이동 생성자","title":"씹어먹는 C++ - <12 - 1. 우측값 레퍼런스와 이동 생성자>"},"228":{"cat_title":"12 - 2. Move 문법 (std::move semantics) 과 완벽한 전달 (perfect forwarding)","next_page":"229","path":"/C++","prev_page":"227","publish_date":"2018-03-27","tex_title":"move 문법과 완벽한 전달","title":"씹어먹는 C++ - <12 - 2. Move 문법 (std::move semantics) 과 완벽한 전달 (perfect forwarding)>"},"229":{"cat_title":"13 - 1. 객체의 유일한 소유권 - unique_ptr","chapter":"스마트 포인터","next_page":"252","path":"/C++","prev_page":"228","publish_date":"2018-09-18","title":"씹어먹는 C ++ - <13 - 1. 객체의 유일한 소유권 - unique_ptr>"},"230":{"cat_title":"11. C++ 에서 예외 처리","chapter":"C++ 에서의 예외 처리","next_page":"227","path":"/C++","prev_page":"292","publish_date":"2018-09-17","title":"씹어먹는 C ++ - <11. C++ 에서 예외 처리>"},"231":{"cat_title":"씹어먹는 C 언어 시작하기","next_page":"315","path":"/C","publish_date":"2009-04-15","title":"씹어먹는 C 언어 시작하기"},"232":{"is_published":"false","path":"/잡담","publish_date":"2010-09-01","title":"옛날 본인 소개"},"233":{"cat_title":"<string>","path":"/C++ Reference/string","ref_title":"<string>","title":"C++ 레퍼런스 - string 라이브러리","publish_date":"2018-12-31"},"234":{"cat_title":"basic_string","path":"/C++ Reference/string","ref_title":"basic_string, std::basic_string","title":"C++ 레퍼런스 - basic_string","publish_date":"2018-12-31"},"235":{"cat_title":"substr","path":"/C++ Reference/string","ref_title":"substr, basic_string::substr","title":"C++ 레퍼런스 - string 의 substr 함수","publish_date":"2018-12-31"},"236":{"cat_title":"getline","path":"/C++ Reference/string","ref_title":"getline, string::getline","title":"C++ 레퍼런스 - string 의 getline 함수","publish_date":"2018-12-31"},"237":{"cat_title":"string 생성자","path":"/C++ Reference/string","ref_title":"string, wstring, std::string, std::wstring, std::u16string, std::u32string","title":"C++ 레퍼런스 - string 생성자","publish_date":"2018-12-31"},"238":{"cat_title":"insert","path":"/C++ Reference/string","ref_title":"insert","title":"C++ 레퍼런스 - string 의 insert 함수","publish_date":"2018-12-31"},"239":{"cat_title":"basic_string_view","path":"/C++ Reference/string_view","ref_title":"basic_string_view, std::basic_string_view","title":"C++ 레퍼런스 - basic_string_view","publish_date":"2018-12-31"},"240":{"cat_title":"erase","path":"/C++ Reference/string","ref_title":"erase, basic_string::erase","title":"C++ 레퍼런스 - string 의 erase 함수","publish_date":"2018-12-31"},"241":{"cat_title":"find","path":"/C++ Reference/string","ref_title":"find, basic_string::find","title":"C++ 레퍼런스 - string 의 find 함수","publish_date":"2018-12-31"},"242":{"cat_title":"string_view","path":"/C++ Reference/string_view","ref_title":"string_view, std::string_view, wstring_view, std::wstring_view","title":"C++ 레퍼런스 - string_view 생성자","publish_date":"2018-12-31"},"243":{"cat_title":"malloc","path":"/C Reference/stdlib.h","ref_title":"malloc","title":"C 언어 레퍼런스 - malloc 함수","publish_date":"2018-12-31"},"244":{"cat_title":"free","path":"/C Reference/stdlib.h","ref_title":"free","title":"C 언어 레퍼런스 - free 함수","publish_date":"2018-12-31"},"245":{"cat_title":"모두의 알고리즘 강좌 시작하기","next_page":"246","path":"/알고리즘","title":"모두의 알고리즘 강좌 시작하기","publish_date":"2018-12-31"},"246":{"cat_title":"1. 어떤 알고리즘이 효율적인가?","next_page":"247","path":"/알고리즘","prev_page":"245","title":"모두의 알고리즘 - 1. 어떤 알고리즘이 효율적인가?","publish_date":"2018-12-31"},"247":{"cat_title":"2 - 1. 정렬 알고리즘과 분할 정복","next_page":"248","path":"/알고리즘","prev_page":"246","title":"모두의 알고리즘 - 2 - 1. 정렬 알고리즘과 분할 정복","publish_date":"2018-12-31"},"248":{"cat_title":"2 - 2. 정렬 알고리즘의 꽃 - 퀵 소트(Quicksort)","next_page":"274","path":"/알고리즘","prev_page":"247","title":"모두의 알고리즘 - 2 - 2. 정렬 알고리즘의 꽃 - 퀵 소트(Quicksort)","publish_date":"2018-12-31"},"249":{"cat_title":"find_first_of","path":"/C++ Reference/string","ref_title":"find_first_of, basic_string::find_first_of","title":"C++ 레퍼런스 - string 의 find_first_of 함수","publish_date":"2018-12-31"},"250":{"cat_title":"replace","path":"/C++ Reference/string","ref_title":"replace, basic_string::replace","title":"C++ 레퍼런스 - string 의 replace 함수","publish_date":"2018-12-31"},"251":{"cat_title":"본인 소개","path":"/잡담/본인 소개","publish_date":"2018-12-08","title":"본인 소개 (2018-12-08) 업데이트"},"252":{"cat_title":"13 - 2. 자원을 공유할 때 - shared_ptr 와 weak_ptr","next_page":"254","path":"/C++","prev_page":"229","publish_date":"2018-12-21","tex_title":"여러 객체가 소유할 수 있는 포인터","title":"씹어먹는 C ++ - <13 - 2. 자원을 공유할 때 - shared_ptr 와 weak_ptr>"},"253":{"cat_title":"4 - 6. 클래스의 explicit 과 mutable 키워드","next_page":"202","path":"/C++","prev_page":"198","publish_date":"2018-12-26","tex_title":"클래스의 explicit 과 mutable 키워드","title":"씹어먹는 C ++ - <4 - 6. 클래스의 explicit 과 mutable 키워드>"},"254":{"cat_title":"14. 함수를 객체로! (C++ std::function, std::mem_fn, std::bind)","chapter":"함수 객체","next_page":"269","path":"/C++","prev_page":"252","publish_date":"2019-02-24","title":"씹어먹는 C ++ - <14. 함수를 객체로! (C++ std::function, std::mem_fn, std::bind)>"},"255":{"cat_title":"씹어먹는 C ++ 토막글 3 - SFINAE 와 enable_if","path":"/C++","publish_date":"2019-01-05","title":"씹어먹는 C ++ 토막글 3 - SFINAE 와 enable_if"},"256":{"cat_title":"<algorithm>","path":"/C++ Reference/algorithm","publish_date":"2019-01-16","ref_title":"algorithm, <algorithm>","title":"C++ 레퍼런스 - algorithm 라이브러리"},"257":{"cat_title":"all_of","path":"/C++ Reference/algorithm","publish_date":"2019-01-16","ref_title":"all_of, std::all_of","title":"C++ 레퍼런스 - all_of 함수"},"258":{"cat_title":"any_of","path":"/C++ Reference/algorithm","publish_date":"2019-01-17","ref_title":"any_of, std::any_of","title":"C++ 레퍼런스 - any_of 함수"},"259":{"cat_title":"none_of","path":"/C++ Reference/algorithm","publish_date":"2019-01-19","ref_title":"none_of, std::none_of","title":"C++ 레퍼런스 - none_of 함수"},"260":{"cat_title":"for_each","path":"/C++ Reference/algorithm","publish_date":"2019-01-19","ref_title":"for_each, std::for_each","title":"C++ 레퍼런스 - for_each 함수"},"261":{"cat_title":"find","path":"/C++ Reference/algorithm","publish_date":"2019-01-19","ref_title":"find, std::find","title":"C++ 레퍼런스 - find 함수 (<algorithm>)"},"262":{"cat_title":"count, count_if","path":"/C++ Reference/algorithm","publish_date":"2019-02-01","ref_title":"count, std::count, count_if, std::count_if","title":"C++ 레퍼런스 - count 와 count_if 함수 (<algorithm>)"},"263":{"cat_title":"find_if","path":"/C++ Reference/algorithm","publish_date":"2019-02-04","ref_title":"find_if, std::find_if","title":"C++ 레퍼런스 - find_if 함수 (<algorithm>)"},"264":{"cat_title":"find_if_not","path":"/C++ Reference/algorithm","publish_date":"2019-02-04","ref_title":"find_if_not, std::find_if_not","title":"C++ 레퍼런스 - find_if_not 함수 (<algorithm>)"},"265":{"cat_title":"find_end","path":"/C++ Reference/algorithm","publish_date":"2019-02-04","ref_title":"find_end, std::find_end","title":"C++ 레퍼런스 - find_end 함수 (<algorithm>)"},"266":{"cat_title":"remove, remove_if","path":"/C++ Reference/algorithm","publish_date":"2019-02-18","ref_title":"remove, std::remove, remove_if, std::remove_if","title":"C++ 레퍼런스 - remove 와 remove_if 함수 (<algorithm>)"},"267":{"cat_title":"fill","path":"/C++ Reference/algorithm","publish_date":"2019-02-18","ref_title":"fill, std::fill","title":"C++ 레퍼런스 - fill 함수 (<algorithm>)"},"268":{"cat_title":"search","path":"/C++ Reference/algorithm","publish_date":"2020-10-16","ref_title":"std::search, search","title":"C++ 레퍼런스 - std::search (<algorithm>)"},"269":{"cat_title":"15 - 1. 동시에 실행을 시킨다고? - C++ 쓰레드(thread)","chapter":"C++ 쓰레드","next_page":"270","path":"/C++","prev_page":"254","publish_date":"2019-04-01","title":"씹어먹는 C ++ - <15 - 1. 동시에 실행을 시킨다고? - C++ 쓰레드(thread)>"},"270":{"cat_title":"15 - 2. C++ 뮤텍스(mutex) 와 조건 변수(condition variable)","next_page":"271","path":"/C++","prev_page":"269","publish_date":"2019-04-03","tex_title":"뮤텍스와 조건변수","title":"씹어먹는 C ++ - <15 - 2. C++ 뮤텍스(mutex) 와 조건 변수(condition variable)>"},"271":{"cat_title":"15 - 3. C++ memory order 와 atomic 객체","next_page":"284","path":"/C++","prev_page":"270","publish_date":"2019-04-07","tex_title":"atomic 객체와 명령어 재배치","title":"씹어먹는 C++ - <15 - 3. C++ memory order 와 atomic 객체>"},"272":{"cat_title":"sort","path":"/C++ Reference/algorithm","publish_date":"2019-04-10","ref_title":"sort, std::sort","title":"C++ 레퍼런스 - sort 함수 (<algorithm>)"},"273":{"cat_title":"partition","path":"/C++ Reference/algorithm","publish_date":"2019-04-13","ref_title":"partition, std::partition","title":"C++ 레퍼런스 - partition 함수 (<algorithm>)"},"274":{"cat_title":"2 - 3. 비교 기반 정렬 알고리즘의 한계와 정수 정렬 알고리즘들","next_page":"287","path":"/알고리즘","prev_page":"248","publish_date":"2019-04-17","title":"모두의 알고리즘 - 2 - 3. 비교 기반 정렬 알고리즘의 한계와 정수 정렬 알고리즘들"},"275":{"cat_title":"transform","path":"/C++ Reference/algorithm","publish_date":"2019-04-19","ref_title":"transform, std::transform","title":"C++ 레퍼런스 - transform 함수"},"276":{"cat_title":"istream::read","path":"/C++ Reference/iostream","publish_date":"2019-04-19","ref_title":"read, istream::read","title":"C++ 레퍼런스 - istream::read 함수"},"277":{"cat_title":"istream::sentry","path":"/C++ Reference/iostream","publish_date":"2019-04-19","ref_title":"sentry, istream::sentry","title":"C++ 레퍼런스 - istream::sentry 클래스"},"278":{"cat_title":"istream::tellg","path":"/C++ Reference/iostream","publish_date":"2019-04-19","ref_title":"tellg, istream::tellg","title":"C++ 레퍼런스 - istream::tellg 함수"},"279":{"cat_title":"istream::seekg","path":"/C++ Reference/iostream","publish_date":"2019-04-19","ref_title":"seekg, istream::seekg","title":"C++ 레퍼런스 - istream::seekg 함수"},"280":{"cat_title":"cin, wcin","path":"/C++ Reference/iostream","publish_date":"2019-04-25","ref_title":"cin, wcin, std::cin, std::wcin","title":"C++ 레퍼런스 - cin, wcin 객체"},"281":{"cat_title":"ios_base::sync_with_stdio","path":"/C++ Reference/iostream","publish_date":"2019-04-26","ref_title":"ios_base::sync_with_stdio, sync_with_stdio","title":"C++ 레퍼런스 - ios_base::sync_with_stdio 함수"},"282":{"cat_title":"std::dec, hex, oct","path":"/C++ Reference/iostream","publish_date":"2019-04-27","ref_title":"std::dec, std::hex, std::oct, dec, hex, oct","title":"C++ 레퍼런스 - std::dec, hex, oct 조작자들"},"283":{"cat_title":"ifstream 생성자","path":"/C++ Reference/iostream","publish_date":"2019-04-28","ref_title":"ifstream::ifstream","title":"C++ 레퍼런스 - ifstream 생성자"},"284":{"cat_title":"15 - 4. C++ future, promise, packaged_task, async","next_page":"285","path":"/C++","prev_page":"271","publish_date":"2019-05-18","tex_title":"비동기 연산을 위한 도구들","title":"씹어먹는 C++ - <15 - 4. C++ future, promise, packaged_task, async>"},"285":{"cat_title":"15 - 5. C++ 쓰레드풀(ThreadPool) 만들기","next_page":"286","path":"/C++","prev_page":"284","publish_date":"2019-05-19","tex_title":"ThreadPool 만들기","title":"씹어먹는 C++ - <15 - 5. C++ 쓰레드풀(ThreadPool) 만들기>"},"286":{"cat_title":"16 - 1. C++ 유니폼 초기화(Uniform Initialization)","chapter":"C++ 유니폼 초기화","next_page":"293","path":"/C++","prev_page":"285","publish_date":"2019-06-23","title":"씹어먹는 C++ - <16 - 1. C++ 유니폼 초기화(Uniform Initialization)>"},"287":{"cat_title":"2 - 4. k 번째 원소를 찾는 알고리즘 - QuickSelect","path":"/알고리즘","prev_page":"274","publish_date":"2019-06-28","title":"모두의 알고리즘 - 2 - 4. k 번째 원소를 찾는 알고리즘 - QuickSelect"},"288":{"cat_title":"iter_swap","path":"/C++ Reference/algorithm","publish_date":"2019-06-30","ref_title":"iter_swap, std::iter_swap","title":"C++ 레퍼런스 - iter_swap 함수 (<algorithm>)"},"289":{"cat_title":"reverse","path":"/C++ Reference/algorithm","publish_date":"2019-07-02","ref_title":"reverse, std::reverse","title":"C++ 레퍼런스 - reverse 함수 (<algorithm>)"},"290":{"cat_title":"9 - 2. 가변 길이 템플릿 (Variadic template)","next_page":"221","path":"/C++","prev_page":"219","publish_date":"2019-07-08","tex_title":"가변 길이 템플릿","title":"씹어먹는 C++ - <9 - 2. 가변 길이 템플릿 (Variadic template)>"},"291":{"cat_title":"nth_element","path":"/C++ Reference/algorithm","publish_date":"2019-07-05","ref_title":"nth_element, std::nth_element","title":"C++ 레퍼런스 - nth_element 함수 (<algorithm>)"},"292":{"cat_title":"10 - 4. C++ 문자열의 모든 것 (string 과 string_view)","next_page":"230","path":"/C++","prev_page":"225","publish_date":"2019-07-17","tex_title":"C++ 문자열의 모든 것 (string 과 string_view)","title":"씹어먹는 C++ - <10 - 4. C++ 문자열의 모든 것 (string 과 string_view)>"},"293":{"cat_title":"16 - 2. constexpr 와 함께라면 컴파일 타임 상수는 문제없어","chapter":"컴파일 타임 상수 constexpr","next_page":"294","path":"/C++","prev_page":"286","publish_date":"2019-08-18","title":"씹어먹는 C++ - <16 - 2. constexpr 와 함께라면 컴파일 타임 상수는 문제없어>"},"294":{"cat_title":"16 - 3. 타입을 알려주는 키워드 decltype 와 친구 std::declval","chapter":"decltype 와 std::decval","next_page":"295","path":"/C++","prev_page":"293","publish_date":"2019-09-15","title":"씹어먹는 C++ - <16 - 3. 타입을 알려주는 키워드 decltype 와 친구 std::declval>"},"295":{"cat_title":"17 - 1. type_traits 라이브러리, SFINAE, enable_if","chapter":"다양한 C++ 표준 라이브러리 소개","next_page":"303","path":"/C++","prev_page":"294","publish_date":"2019-12-2","tex_title":"type_traits 라이브러리, SFINAE, enable_if","title":"씹어먹는 C++ - <17 - 1. type_traits 라이브러리, SFINAE, enable_if>"},"296":{"cat_title":"stoi, stol, stoll","path":"/C++ Reference/string","publish_date":"2019-09-19","ref_title":"stoi, stol, stoll, std::stoi, std::stol, std::stoll","title":"C++ 레퍼런스 - string 의 stoi, stol, stoll 함수"},"297":{"cat_title":"c_str","path":"/C++ Reference/string","publish_date":"2019-09-19","ref_title":"c_str, std::c_str","title":"C++ 레퍼런스 - string 의 c_str 함수"},"298":{"cat_title":"lower_bound, upper_bound","path":"/C++ Reference/algorithm","publish_date":"2019-09-20","ref_title":"lower_bound, upper_bound, std::lower_bound, std::upper_bound","title":"C++ 레퍼런스 - std::lower_bound 와 upper_bound (<algorithm>)"},"299":{"cat_title":"<utility>","path":"/C++ Reference/utility","publish_date":"2019-09-20","ref_title":"<utility>","title":"C++ 레퍼런스 - utility 라이브러리"},"300":{"cat_title":"300 번째 글을 올리면서","path":"/잡담","publish_date":"2019-09-26","title":"300 번째 글을 올리면서"},"301":{"cat_title":"move","path":"/C++ Reference/utility","publish_date":"2019-09-26","ref_title":"move, std::move","title":"C++ 레퍼런스 - std::move 함수"},"302":{"cat_title":"forward","path":"/C++ Reference/utility","publish_date":"2019-09-28","ref_title":"forward, std::forward","title":"C++ 레퍼런스 - std::forward 함수"},"303":{"cat_title":"17 - 2. C++ 정규 표현식(<regex>) 라이브러리 소개","next_page":"304","path":"/C++","prev_page":"295","publish_date":"2020-1-3","tex_title":"정규 표현식(<regex>) 라이브러리 소개","title":"씹어먹는 C++ - <17 - 2. C++ 정규 표현식(<regex>) 라이브러리 소개>"},"304":{"cat_title":"17 - 3. 난수 생성(<random>)과 시간 관련 라이브러리(<chrono>) 소개","next_page":"306","path":"/C++","prev_page":"303","publish_date":"2020-1-6","tex_title":"난수 생성(<random>)과 시간 관련 라이브러리(<chrono>) 소개","title":"씹어먹는 C++ - <17 - 3. 난수 생성(<random>)과 시간 관련 라이브러리(<chrono>) 소개>"},"305":{"cat_title":"copy, copy_if","path":"/C++ Reference/algorithm","publish_date":"2020-01-30","ref_title":"copy, copy_if, std::copy, std::copy_if","title":"C++ 레퍼런스 - std::copy 와 copy_if (<algorithm>)"},"306":{"cat_title":"17 - 4. C++ 파일 시스템(<filesystem>) 라이브러리 소개","next_page":"309","path":"/C++","prev_page":"304","publish_date":"2020-03-11","tex_title":"C++ 파일 시스템(<filesystem>) 라이브러리 소개","title":"씹어먹는 C++ - <17 - 4. C++ 파일 시스템(<filesystem>) 라이브러리 소개>"},"307":{"cat_title":"append","path":"/C++ Reference/string","publish_date":"2020-03-10","ref_title":"append","title":"C++ 레퍼런스 - string 의 append 함수"},"308":{"cat_title":"4 - 2. 컴퓨터가 수를 표현하는 방법 (2의 보수)","next_page":"9","path":"/C","prev_page":"8","publish_date":"2020-04-29","tex_title":"컴퓨터가 음수를 표현하는 방법 (2의 보수)","title":"씹어먹는 C 언어 - <4 - 2. 컴퓨터가 음수를 표현하는 방법 (2의 보수)>"},"309":{"cat_title":"17 - 5. C++ 17 의 std::optional, variant, tuple 살펴보기","next_page":"310","path":"/C++","prev_page":"306","publish_date":"2020-05-05","tex_title":"C++ 유틸리티 라이브러리 소개","title":"씹어먹는 C++ - <17 - 5. C++ 17 의 std::optional, variant, tuple 살펴보기>"},"310":{"cat_title":"초보자를 위한 C++ 강좌 - 씹어먹는 C++ (완결)","chapter":"강의를 마무리 하면서","next_page":"311","path":"/C++","prev_page":"309","publish_date":"2020-05-10","title":"초보자를 위한 C++ 강좌 - 씹어먹는 C++ (완결)"},"311":{"cat_title":"19 - 1. Make 사용 가이드 (Makefile 만들기)","chapter":"C++ 개발자가 알면 좋을 것들","next_page":"332","path":"/C++","prev_page":"310","publish_date":"2020-06-10","tex_title":"Make 사용 가이드 (Makefile 만들기)","title":"씹어먹는 C++ - <19 - 1. Make 사용 가이드 (Makefile 만들기)>"},"312":{"cat_title":"씹어먹는 C++ 강좌 - PDF 파일","path":"/C++","publish_date":"2020-06-17","title":"씹어먹는 C++ 강좌 - PDF 파일"},"313":{"cat_title":"컴파일러는 정수 나눗셈을 어떻게 최적화 할까?","path":"/프로그래밍","publish_date":"2020-07-06","title":"컴파일러는 정수 나눗셈을 어떻게 최적화 할까?"},"314":{"cat_title":"std::array","path":"/C++ Reference/array","publish_date":"2020-07-17","ref_title":"std::array, array","title":"C++ 레퍼런스 - std::array (안전한 배열)"},"315":{"next_page":"5","path":"/C","prev_page":"231","publish_date":"2020-09-06","title":"내가 C 언어를 공부하기 전에 알았으면 좋았을 것들"},"316":{"path":"/X86-64 명령어 레퍼런스","publish_date":"2020-09-09","title":"x86-64 명령어 레퍼런스 읽는 법"},"317":{"cat_title":"replace, replace_if","path":"/C++ Reference/algorithm","publish_date":"2020-09-20","ref_title":"std::replace, replace, std::replace_if, replace_if","title":"C++ 레퍼런스 - std::replace 와 std::replace_if (<algorithm>)"},"318":{"cat_title":"generate","path":"/C++ Reference/algorithm","publish_date":"2020-09-23","ref_title":"std::generate, generate","title":"C++ 레퍼런스 - std::generate (<algorithm>)"},"319":{"cat_title":"20 - 1. 코드 부터 실행 파일 까지","next_page":"320","path":"/C++","prev_page":"332","publish_date":"2020-10-20","title":"씹어먹는 C++ - <20 - 1. 코드 부터 실행 파일 까지 - 전체적인 개요>"},"320":{"cat_title":"20 - 2.코드 부터 실행 파일 까지 - 컴파일 (Compile)","next_page":"321","path":"/C++","prev_page":"319","publish_date":"2020-10-20","title":"씹어먹는 C++ - <20 - 2. 코드 부터 실행 파일 까지 - 컴파일 (Compile)>"},"321":{"cat_title":"20 - 3. 코드 부터 실행 파일 까지 - 링킹 (Linking)","next_page":"322","path":"/C++","prev_page":"320","publish_date":"2020-11-25","title":"씹어먹는 C++ - <20 - 3. 코드 부터 실행 파일 까지 - 링킹 (Linking)>"},"322":{"cat_title":"20 - 4. 코드 부터 실행 파일 까지 - main 으로의 여정","next_page":"326","path":"/C++","prev_page":"321","publish_date":"2020-11-30","title":"씹어먹는 C++ - <20 - 4. 코드 부터 실행 파일 까지 - main 으로의 여정>"},"323":{"cat_title":"stable_sort","path":"/C++ Reference/algorithm","publish_date":"2020-12-06","ref_title":"std::stable_sort, stable_sort","title":"C++ 레퍼런스 - std::stable_sort (<algorithm>)"},"324":{"cat_title":"partial_sort","path":"/C++ Reference/algorithm","publish_date":"2020-12-06","ref_title":"std::partial_sort, partial_sort","title":"C++ 레퍼런스 - std::partial_sort (<algorithm>)"},"325":{"cat_title":"binary_search","path":"/C++ Reference/algorithm","publish_date":"2020-12-07","ref_title":"std::binary_search, binary_search","title":"C++ 레퍼런스 - std::binary_search (<algorithm>)"},"326":{"cat_title":"21. C++ 표준 라이브러리에서 자주 쓰이는 패턴 모음","next_page":"335","path":"/C++","prev_page":"322","publish_date":"2021-01-15","title":"씹어먹는 C++ - <21. C++ 표준 라이브러리에서 자주 쓰이는 패턴 모음>"},"327":{"path":"/잡담","publish_date":"2021-01-18","title":"2020년 마무리 및 2021년 계획"},"328":{"next_page":"329","path":"/자료 구조","publish_date":"2021-02-05","title":"모두를 위한 자료구조"},"329":{"path":"/자료 구조","prev_page":"328","publish_date":"2021-02-05","title":"모두의 자료구조 - 1. 배열(Array)"},"332":{"cat_title":"19 - 2. C++ 프로젝트를 위한 CMake 사용법","next_page":"319","path":"/C++","prev_page":"311","publish_date":"2021-02-24","tex_title":"CMake 사용 가이드","title":"씹어먹는 C++ - <19 - 2. C++ 프로젝트를 위한 CMake 사용법>"},"333":{"cat_title":"Rust 의 static 키워드","path":"/Rust","publish_date":"2021-06-10","title":"Rust 의 static 키워드"},"334":{"cat_title":"Rust 의 다형성 - static 과 dynamic dispatch","path":"/Rust","publish_date":"2021-08-15","title":"Rust 의 다형성 - static 과 dynamic dispatch (C++ 을 곁들인..)"},"335":{"cat_title":"22. 구글에서는 C++ 을 어떻게 쓰는가?","path":"/C++","prev_page":"326","publish_date":"2022-02-15","tex_title":"구글에서는 C++ 을 어떻게 쓰는가?","title":"씹어먹는 C++ - <22. 구글에서는 C++ 을 어떻게 쓰는가?>"},"aaa":{"cat_title":"AAA","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AAA","title":"AAA (Intel x86/64 assembly instruction)"},"aad":{"cat_title":"AAD","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AAD","title":"AAD (Intel x86/64 assembly instruction)"},"aam":{"cat_title":"AAM","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AAM","title":"AAM (Intel x86/64 assembly instruction)"},"aas":{"cat_title":"AAS","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AAS","title":"AAS (Intel x86/64 assembly instruction)"},"adc":{"cat_title":"ADC","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADC","title":"ADC (Intel x86/64 assembly instruction)"},"adcx":{"cat_title":"ADCX","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADCX","title":"ADCX (Intel x86/64 assembly instruction)"},"add":{"cat_title":"ADD","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADD","title":"ADD (Intel x86/64 assembly instruction)"},"addpd":{"cat_title":"ADDPD","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADDPD","title":"ADDPD (Intel x86/64 assembly instruction)"},"addps":{"cat_title":"ADDPS","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADDPS","title":"ADDPS (Intel x86/64 assembly instruction)"},"addsd":{"cat_title":"ADDSD","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADDSD","title":"ADDSD (Intel x86/64 assembly instruction)"},"addss":{"cat_title":"ADDSS","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADDSS","title":"ADDSS (Intel x86/64 assembly instruction)"},"addsubpd":{"cat_title":"ADDSUBPD","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADDSUBPD","title":"ADDSUBPD (Intel x86/64 assembly instruction)"},"addsubps":{"cat_title":"ADDSUBPS","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADDSUBPS","title":"ADDSUBPS (Intel x86/64 assembly instruction)"},"adox":{"cat_title":"ADOX","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ADOX","title":"ADOX (Intel x86/64 assembly instruction)"},"aesdec":{"cat_title":"AESDEC","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AESDEC","title":"AESDEC (Intel x86/64 assembly instruction)"},"aesdeclast":{"cat_title":"AESDECLAST","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AESDECLAST","title":"AESDECLAST (Intel x86/64 assembly instruction)"},"aesenc":{"cat_title":"AESENC","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AESENC","title":"AESENC (Intel x86/64 assembly instruction)"},"aesenclast":{"cat_title":"AESENCLAST","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AESENCLAST","title":"AESENCLAST (Intel x86/64 assembly instruction)"},"aesimc":{"cat_title":"AESIMC","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AESIMC","title":"AESIMC (Intel x86/64 assembly instruction)"},"aeskeygenassist":{"cat_title":"AESKEYGENASSIST","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AESKEYGENASSIST","title":"AESKEYGENASSIST (Intel x86/64 assembly instruction)"},"and":{"cat_title":"AND","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"AND","title":"AND (Intel x86/64 assembly instruction)"},"andn":{"cat_title":"ANDN","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ANDN","title":"ANDN (Intel x86/64 assembly instruction)"},"andnpd":{"cat_title":"ANDNPD","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ANDNPD","title":"ANDNPD (Intel x86/64 assembly instruction)"},"andnps":{"cat_title":"ANDNPS","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ANDNPS","title":"ANDNPS (Intel x86/64 assembly instruction)"},"andpd":{"cat_title":"ANDPD","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ANDPD","title":"ANDPD (Intel x86/64 assembly instruction)"},"andps":{"cat_title":"ANDPS","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ANDPS","title":"ANDPS (Intel x86/64 assembly instruction)"},"arpl":{"cat_title":"ARPL","path":"/X86-64 명령어 레퍼런스/A","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ARPL","title":"ARPL (Intel x86/64 assembly instruction)"},"bextr":{"cat_title":"BEXTR","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BEXTR","title":"BEXTR (Intel x86/64 assembly instruction)"},"blendpd":{"cat_title":"BLENDPD","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BLENDPD","title":"BLENDPD (Intel x86/64 assembly instruction)"},"blendps":{"cat_title":"BLENDPS","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BLENDPS","title":"BLENDPS (Intel x86/64 assembly instruction)"},"blendvpd":{"cat_title":"BLENDVPD","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BLENDVPD","title":"BLENDVPD (Intel x86/64 assembly instruction)"},"blendvps":{"cat_title":"BLENDVPS","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BLENDVPS","title":"BLENDVPS (Intel x86/64 assembly instruction)"},"blsi":{"cat_title":"BLSI","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BLSI","title":"BLSI (Intel x86/64 assembly instruction)"},"blsmsk":{"cat_title":"BLSMSK","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BLSMSK","title":"BLSMSK (Intel x86/64 assembly instruction)"},"blsr":{"cat_title":"BLSR","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BLSR","title":"BLSR (Intel x86/64 assembly instruction)"},"bndcl":{"cat_title":"BNDCL","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BNDCL","title":"BNDCL (Intel x86/64 assembly instruction)"},"bndcu-bndcn":{"cat_title":"BNDCU, BNDCN","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BNDCU, BNDCN","title":"BNDCU, BNDCNs (Intel x86/64 assembly instruction)"},"bndldx":{"cat_title":"BNDLDX","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BNDLDX","title":"BNDLDX (Intel x86/64 assembly instruction)"},"bndmk":{"cat_title":"BNDMK","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BNDMK","title":"BNDMK (Intel x86/64 assembly instruction)"},"bndmov":{"cat_title":"BNDMOV","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BNDMOV","title":"BNDMOV (Intel x86/64 assembly instruction)"},"bndstx":{"cat_title":"BNDSTX","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BNDSTX","title":"BNDSTX (Intel x86/64 assembly instruction)"},"bound":{"cat_title":"BOUND","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BOUND","title":"BOUND (Intel x86/64 assembly instruction)"},"bsf":{"cat_title":"BSF","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BSF","title":"BSF (Intel x86/64 assembly instruction)"},"bsr":{"cat_title":"BSR","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BSR","title":"BSR (Intel x86/64 assembly instruction)"},"bswap":{"cat_title":"BSWAP","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BSWAP","title":"BSWAP (Intel x86/64 assembly instruction)"},"bt":{"cat_title":"BT","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BT","title":"BT (Intel x86/64 assembly instruction)"},"btc":{"cat_title":"BTC","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BTC","title":"BTC (Intel x86/64 assembly instruction)"},"btr":{"cat_title":"BTR","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BTR","title":"BTR (Intel x86/64 assembly instruction)"},"bts":{"cat_title":"BTS","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BTS","title":"BTS (Intel x86/64 assembly instruction)"},"bzhi":{"cat_title":"BZHI","path":"/X86-64 명령어 레퍼런스/B","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"BZHI","title":"BZHI (Intel x86/64 assembly instruction)"},"call":{"cat_title":"CALL","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CALL","title":"CALL (Intel x86/64 assembly instruction)"},"cbw-cwde-cdqe":{"cat_title":"CBW, CWDE, CDQE","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CBW, CWDE, CDQE","title":"CBW, CWDE, CDQEs (Intel x86/64 assembly instruction)"},"clac":{"cat_title":"CLAC","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CLAC","title":"CLAC (Intel x86/64 assembly instruction)"},"clc":{"cat_title":"CLC","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CLC","title":"CLC (Intel x86/64 assembly instruction)"},"cld":{"cat_title":"CLD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CLD","title":"CLD (Intel x86/64 assembly instruction)"},"clflush":{"cat_title":"CLFLUSH","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CLFLUSH","title":"CLFLUSH (Intel x86/64 assembly instruction)"},"clflushopt":{"cat_title":"CLFLUSHOPT","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CLFLUSHOPT","title":"CLFLUSHOPT (Intel x86/64 assembly instruction)"},"cli":{"cat_title":"CLI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CLI","title":"CLI (Intel x86/64 assembly instruction)"},"clts":{"cat_title":"CLTS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CLTS","title":"CLTS (Intel x86/64 assembly instruction)"},"clwb":{"cat_title":"CLWB","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CLWB","title":"CLWB (Intel x86/64 assembly instruction)"},"cmc":{"cat_title":"CMC","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMC","title":"CMC (Intel x86/64 assembly instruction)"},"cmovcc":{"cat_title":"CMOVcc","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMOVcc","title":"CMOVcc (Intel x86/64 assembly instruction)"},"cmp":{"cat_title":"CMP","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMP","title":"CMP (Intel x86/64 assembly instruction)"},"cmppd":{"cat_title":"CMPPD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMPPD","title":"CMPPD (Intel x86/64 assembly instruction)"},"cmpps":{"cat_title":"CMPPS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMPPS","title":"CMPPS (Intel x86/64 assembly instruction)"},"cmps-cmpsb-cmpsw-cmpsd-cmpsq":{"cat_title":"CMPS, CMPSB, CMPSW, CMPSD, CMPSQ","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMPS, CMPSB, CMPSW, CMPSD, CMPSQ","title":"CMPS, CMPSB, CMPSW, CMPSD, CMPSQs (Intel x86/64 assembly instruction)"},"cmpsd":{"cat_title":"CMPSD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMPSD","title":"CMPSD (Intel x86/64 assembly instruction)"},"cmpss":{"cat_title":"CMPSS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMPSS","title":"CMPSS (Intel x86/64 assembly instruction)"},"cmpxchg":{"cat_title":"CMPXCHG","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMPXCHG","title":"CMPXCHG (Intel x86/64 assembly instruction)"},"cmpxchg8b-cmpxchg16b":{"cat_title":"CMPXCHG8B, CMPXCHG16B","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CMPXCHG8B, CMPXCHG16B","title":"CMPXCHG8B, CMPXCHG16Bs (Intel x86/64 assembly instruction)"},"comisd":{"cat_title":"COMISD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"COMISD","title":"COMISD (Intel x86/64 assembly instruction)"},"comiss":{"cat_title":"COMISS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"COMISS","title":"COMISS (Intel x86/64 assembly instruction)"},"cpuid":{"cat_title":"CPUID","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CPUID","title":"CPUID (Intel x86/64 assembly instruction)"},"crc32":{"cat_title":"CRC32","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CRC32","title":"CRC32 (Intel x86/64 assembly instruction)"},"cvtdq2pd":{"cat_title":"CVTDQ2PD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTDQ2PD","title":"CVTDQ2PD (Intel x86/64 assembly instruction)"},"cvtdq2ps":{"cat_title":"CVTDQ2PS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTDQ2PS","title":"CVTDQ2PS (Intel x86/64 assembly instruction)"},"cvtpd2dq":{"cat_title":"CVTPD2DQ","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTPD2DQ","title":"CVTPD2DQ (Intel x86/64 assembly instruction)"},"cvtpd2pi":{"cat_title":"CVTPD2PI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTPD2PI","title":"CVTPD2PI (Intel x86/64 assembly instruction)"},"cvtpd2ps":{"cat_title":"CVTPD2PS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTPD2PS","title":"CVTPD2PS (Intel x86/64 assembly instruction)"},"cvtpi2pd":{"cat_title":"CVTPI2PD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTPI2PD","title":"CVTPI2PD (Intel x86/64 assembly instruction)"},"cvtpi2ps":{"cat_title":"CVTPI2PS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTPI2PS","title":"CVTPI2PS (Intel x86/64 assembly instruction)"},"cvtps2dq":{"cat_title":"CVTPS2DQ","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTPS2DQ","title":"CVTPS2DQ (Intel x86/64 assembly instruction)"},"cvtps2pd":{"cat_title":"CVTPS2PD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTPS2PD","title":"CVTPS2PD (Intel x86/64 assembly instruction)"},"cvtps2pi":{"cat_title":"CVTPS2PI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTPS2PI","title":"CVTPS2PI (Intel x86/64 assembly instruction)"},"cvtsd2si":{"cat_title":"CVTSD2SI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTSD2SI","title":"CVTSD2SI (Intel x86/64 assembly instruction)"},"cvtsd2ss":{"cat_title":"CVTSD2SS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTSD2SS","title":"CVTSD2SS (Intel x86/64 assembly instruction)"},"cvtsi2sd":{"cat_title":"CVTSI2SD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTSI2SD","title":"CVTSI2SD (Intel x86/64 assembly instruction)"},"cvtsi2ss":{"cat_title":"CVTSI2SS","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTSI2SS","title":"CVTSI2SS (Intel x86/64 assembly instruction)"},"cvtss2sd":{"cat_title":"CVTSS2SD","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTSS2SD","title":"CVTSS2SD (Intel x86/64 assembly instruction)"},"cvtss2si":{"cat_title":"CVTSS2SI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTSS2SI","title":"CVTSS2SI (Intel x86/64 assembly instruction)"},"cvttpd2dq":{"cat_title":"CVTTPD2DQ","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTTPD2DQ","title":"CVTTPD2DQ (Intel x86/64 assembly instruction)"},"cvttpd2pi":{"cat_title":"CVTTPD2PI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTTPD2PI","title":"CVTTPD2PI (Intel x86/64 assembly instruction)"},"cvttps2dq":{"cat_title":"CVTTPS2DQ","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTTPS2DQ","title":"CVTTPS2DQ (Intel x86/64 assembly instruction)"},"cvttps2pi":{"cat_title":"CVTTPS2PI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTTPS2PI","title":"CVTTPS2PI (Intel x86/64 assembly instruction)"},"cvttsd2si":{"cat_title":"CVTTSD2SI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTTSD2SI","title":"CVTTSD2SI (Intel x86/64 assembly instruction)"},"cvttss2si":{"cat_title":"CVTTSS2SI","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CVTTSS2SI","title":"CVTTSS2SI (Intel x86/64 assembly instruction)"},"cwd-cdq-cqo":{"cat_title":"CWD, CDQ, CQO","path":"/X86-64 명령어 레퍼런스/C","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"CWD, CDQ, CQO","title":"CWD, CDQ, CQOs (Intel x86/64 assembly instruction)"},"daa":{"cat_title":"DAA","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DAA","title":"DAA (Intel x86/64 assembly instruction)"},"das":{"cat_title":"DAS","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DAS","title":"DAS (Intel x86/64 assembly instruction)"},"dec":{"cat_title":"DEC","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DEC","title":"DEC (Intel x86/64 assembly instruction)"},"div":{"cat_title":"DIV","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DIV","title":"DIV (Intel x86/64 assembly instruction)"},"divpd":{"cat_title":"DIVPD","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DIVPD","title":"DIVPD (Intel x86/64 assembly instruction)"},"divps":{"cat_title":"DIVPS","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DIVPS","title":"DIVPS (Intel x86/64 assembly instruction)"},"divsd":{"cat_title":"DIVSD","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DIVSD","title":"DIVSD (Intel x86/64 assembly instruction)"},"divss":{"cat_title":"DIVSS","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DIVSS","title":"DIVSS (Intel x86/64 assembly instruction)"},"dppd":{"cat_title":"DPPD","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DPPD","title":"DPPD (Intel x86/64 assembly instruction)"},"dpps":{"cat_title":"DPPS","path":"/X86-64 명령어 레퍼런스/D","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"DPPS","title":"DPPS (Intel x86/64 assembly instruction)"},"emms":{"cat_title":"EMMS","path":"/X86-64 명령어 레퍼런스/E","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"EMMS","title":"EMMS (Intel x86/64 assembly instruction)"},"enter":{"cat_title":"ENTER","path":"/X86-64 명령어 레퍼런스/E","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ENTER","title":"ENTER (Intel x86/64 assembly instruction)"},"extractps":{"cat_title":"EXTRACTPS","path":"/X86-64 명령어 레퍼런스/E","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"EXTRACTPS","title":"EXTRACTPS (Intel x86/64 assembly instruction)"},"f2xm1":{"cat_title":"F2XM1","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"F2XM1","title":"F2XM1 (Intel x86/64 assembly instruction)"},"fabs":{"cat_title":"FABS","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FABS","title":"FABS (Intel x86/64 assembly instruction)"},"fadd-faddp-fiadd":{"cat_title":"FADD, FADDP, FIADD","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FADD, FADDP, FIADD","title":"FADD, FADDP, FIADDs (Intel x86/64 assembly instruction)"},"fbld":{"cat_title":"FBLD","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FBLD","title":"FBLD (Intel x86/64 assembly instruction)"},"fbstp":{"cat_title":"FBSTP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FBSTP","title":"FBSTP (Intel x86/64 assembly instruction)"},"fchs":{"cat_title":"FCHS","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FCHS","title":"FCHS (Intel x86/64 assembly instruction)"},"fclex-fnclex":{"cat_title":"FCLEX, FNCLEX","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FCLEX, FNCLEX","title":"FCLEX, FNCLEXs (Intel x86/64 assembly instruction)"},"fcmovcc":{"cat_title":"FCMOVcc","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FCMOVcc","title":"FCMOVcc (Intel x86/64 assembly instruction)"},"fcom-fcomp-fcompp":{"cat_title":"FCOM, FCOMP, FCOMPP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FCOM, FCOMP, FCOMPP","title":"FCOM, FCOMP, FCOMPPs (Intel x86/64 assembly instruction)"},"fcomi-fcomip--fucomip":{"cat_title":"FCOMI, FCOMIP, , FUCOMIP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FCOMI, FCOMIP, , FUCOMIP","title":"FCOMI, FCOMIP, , FUCOMIPs (Intel x86/64 assembly instruction)"},"fcos":{"cat_title":"FCOS","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FCOS","title":"FCOS (Intel x86/64 assembly instruction)"},"fdecstp":{"cat_title":"FDECSTP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FDECSTP","title":"FDECSTP (Intel x86/64 assembly instruction)"},"fdiv-fdivp-fidiv":{"cat_title":"FDIV, FDIVP, FIDIV","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FDIV, FDIVP, FIDIV","title":"FDIV, FDIVP, FIDIVs (Intel x86/64 assembly instruction)"},"fdivr-fdivrp-fidivr":{"cat_title":"FDIVR, FDIVRP, FIDIVR","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FDIVR, FDIVRP, FIDIVR","title":"FDIVR, FDIVRP, FIDIVRs (Intel x86/64 assembly instruction)"},"ffree":{"cat_title":"FFREE","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FFREE","title":"FFREE (Intel x86/64 assembly instruction)"},"ficom-ficomp":{"cat_title":"FICOM, FICOMP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FICOM, FICOMP","title":"FICOM, FICOMPs (Intel x86/64 assembly instruction)"},"fild":{"cat_title":"FILD","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FILD","title":"FILD (Intel x86/64 assembly instruction)"},"fincstp":{"cat_title":"FINCSTP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FINCSTP","title":"FINCSTP (Intel x86/64 assembly instruction)"},"finit-fninit":{"cat_title":"FINIT, FNINIT","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FINIT, FNINIT","title":"FINIT, FNINITs (Intel x86/64 assembly instruction)"},"fist-fistp":{"cat_title":"FIST, FISTP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FIST, FISTP","title":"FIST, FISTPs (Intel x86/64 assembly instruction)"},"fisttp":{"cat_title":"FISTTP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FISTTP","title":"FISTTP (Intel x86/64 assembly instruction)"},"fld":{"cat_title":"FLD","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FLD","title":"FLD (Intel x86/64 assembly instruction)"},"fld1-fldl2t-fldl2e-fldpi-fldlg2-fldln2-fldz":{"cat_title":"FLD1, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, FLDZ","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FLD1, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, FLDZ","title":"FLD1, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, FLDZs (Intel x86/64 assembly instruction)"},"fldcw":{"cat_title":"FLDCW","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FLDCW","title":"FLDCW (Intel x86/64 assembly instruction)"},"fldenv":{"cat_title":"FLDENV","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FLDENV","title":"FLDENV (Intel x86/64 assembly instruction)"},"fmul-fmulp-fimul":{"cat_title":"FMUL, FMULP, FIMUL","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FMUL, FMULP, FIMUL","title":"FMUL, FMULP, FIMULs (Intel x86/64 assembly instruction)"},"fnop":{"cat_title":"FNOP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FNOP","title":"FNOP (Intel x86/64 assembly instruction)"},"fpatan":{"cat_title":"FPATAN","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FPATAN","title":"FPATAN (Intel x86/64 assembly instruction)"},"fprem":{"cat_title":"FPREM","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FPREM","title":"FPREM (Intel x86/64 assembly instruction)"},"fprem1":{"cat_title":"FPREM1","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FPREM1","title":"FPREM1 (Intel x86/64 assembly instruction)"},"fptan":{"cat_title":"FPTAN","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FPTAN","title":"FPTAN (Intel x86/64 assembly instruction)"},"frndint":{"cat_title":"FRNDINT","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FRNDINT","title":"FRNDINT (Intel x86/64 assembly instruction)"},"frstor":{"cat_title":"FRSTOR","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FRSTOR","title":"FRSTOR (Intel x86/64 assembly instruction)"},"fsave-fnsave":{"cat_title":"FSAVE, FNSAVE","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSAVE, FNSAVE","title":"FSAVE, FNSAVEs (Intel x86/64 assembly instruction)"},"fscale":{"cat_title":"FSCALE","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSCALE","title":"FSCALE (Intel x86/64 assembly instruction)"},"fsin":{"cat_title":"FSIN","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSIN","title":"FSIN (Intel x86/64 assembly instruction)"},"fsincos":{"cat_title":"FSINCOS","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSINCOS","title":"FSINCOS (Intel x86/64 assembly instruction)"},"fsqrt":{"cat_title":"FSQRT","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSQRT","title":"FSQRT (Intel x86/64 assembly instruction)"},"fst-fstp":{"cat_title":"FST, FSTP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FST, FSTP","title":"FST, FSTPs (Intel x86/64 assembly instruction)"},"fstcw-fnstcw":{"cat_title":"FSTCW, FNSTCW","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSTCW, FNSTCW","title":"FSTCW, FNSTCWs (Intel x86/64 assembly instruction)"},"fstenv-fnstenv":{"cat_title":"FSTENV, FNSTENV","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSTENV, FNSTENV","title":"FSTENV, FNSTENVs (Intel x86/64 assembly instruction)"},"fstsw-fnstsw":{"cat_title":"FSTSW, FNSTSW","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSTSW, FNSTSW","title":"FSTSW, FNSTSWs (Intel x86/64 assembly instruction)"},"fsub-fsubp-fisub":{"cat_title":"FSUB, FSUBP, FISUB","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSUB, FSUBP, FISUB","title":"FSUB, FSUBP, FISUBs (Intel x86/64 assembly instruction)"},"fsubr-fsubrp-fisubr":{"cat_title":"FSUBR, FSUBRP, FISUBR","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FSUBR, FSUBRP, FISUBR","title":"FSUBR, FSUBRP, FISUBRs (Intel x86/64 assembly instruction)"},"ftst":{"cat_title":"FTST","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FTST","title":"FTST (Intel x86/64 assembly instruction)"},"fucom-fucomp-fucompp":{"cat_title":"FUCOM, FUCOMP, FUCOMPP","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FUCOM, FUCOMP, FUCOMPP","title":"FUCOM, FUCOMP, FUCOMPPs (Intel x86/64 assembly instruction)"},"fxam":{"cat_title":"FXAM","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FXAM","title":"FXAM (Intel x86/64 assembly instruction)"},"fxch":{"cat_title":"FXCH","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FXCH","title":"FXCH (Intel x86/64 assembly instruction)"},"fxrstor":{"cat_title":"FXRSTOR","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FXRSTOR","title":"FXRSTOR (Intel x86/64 assembly instruction)"},"fxsave":{"cat_title":"FXSAVE","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FXSAVE","title":"FXSAVE (Intel x86/64 assembly instruction)"},"fxtract":{"cat_title":"FXTRACT","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FXTRACT","title":"FXTRACT (Intel x86/64 assembly instruction)"},"fyl2x":{"cat_title":"FYL2X","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FYL2X","title":"FYL2X (Intel x86/64 assembly instruction)"},"fyl2xp1":{"cat_title":"FYL2XP1","path":"/X86-64 명령어 레퍼런스/F","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"FYL2XP1","title":"FYL2XP1 (Intel x86/64 assembly instruction)"},"getsec[exitac]":{"cat_title":"GETSEC[EXITAC]","path":"/X86-64 명령어 레퍼런스/G","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"GETSEC[EXITAC]","title":"GETSEC[EXITAC] (Intel x86/64 assembly instruction)"},"getsec[parameters]":{"cat_title":"GETSEC[PARAMETERS]","path":"/X86-64 명령어 레퍼런스/G","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"GETSEC[PARAMETERS]","title":"GETSEC[PARAMETERS] (Intel x86/64 assembly instruction)"},"getsec[senter]":{"cat_title":"GETSEC[SENTER]","path":"/X86-64 명령어 레퍼런스/G","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"GETSEC[SENTER]","title":"GETSEC[SENTER] (Intel x86/64 assembly instruction)"},"getsec[sexit]":{"cat_title":"GETSEC[SEXIT]","path":"/X86-64 명령어 레퍼런스/G","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"GETSEC[SEXIT]","title":"GETSEC[SEXIT] (Intel x86/64 assembly instruction)"},"getsec[smctrl]":{"cat_title":"GETSEC[SMCTRL]","path":"/X86-64 명령어 레퍼런스/G","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"GETSEC[SMCTRL]","title":"GETSEC[SMCTRL] (Intel x86/64 assembly instruction)"},"getsec[wakeup]":{"cat_title":"GETSEC[WAKEUP]","path":"/X86-64 명령어 레퍼런스/G","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"GETSEC[WAKEUP]","title":"GETSEC[WAKEUP] (Intel x86/64 assembly instruction)"},"haddpd":{"cat_title":"HADDPD","path":"/X86-64 명령어 레퍼런스/H","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"HADDPD","title":"HADDPD (Intel x86/64 assembly instruction)"},"haddps":{"cat_title":"HADDPS","path":"/X86-64 명령어 레퍼런스/H","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"HADDPS","title":"HADDPS (Intel x86/64 assembly instruction)"},"hlt":{"cat_title":"HLT","path":"/X86-64 명령어 레퍼런스/H","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"HLT","title":"HLT (Intel x86/64 assembly instruction)"},"hsubpd":{"cat_title":"HSUBPD","path":"/X86-64 명령어 레퍼런스/H","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"HSUBPD","title":"HSUBPD (Intel x86/64 assembly instruction)"},"hsubps":{"cat_title":"HSUBPS","path":"/X86-64 명령어 레퍼런스/H","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"HSUBPS","title":"HSUBPS (Intel x86/64 assembly instruction)"},"idiv":{"cat_title":"IDIV","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"IDIV","title":"IDIV (Intel x86/64 assembly instruction)"},"imul":{"cat_title":"IMUL","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"IMUL","title":"IMUL (Intel x86/64 assembly instruction)"},"in":{"cat_title":"IN","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"IN","title":"IN (Intel x86/64 assembly instruction)"},"inc":{"cat_title":"INC","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"INC","title":"INC (Intel x86/64 assembly instruction)"},"ins-insb-insw-insd":{"cat_title":"INS, INSB, INSW, INSD","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"INS, INSB, INSW, INSD","title":"INS, INSB, INSW, INSDs (Intel x86/64 assembly instruction)"},"insertps":{"cat_title":"INSERTPS","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"INSERTPS","title":"INSERTPS (Intel x86/64 assembly instruction)"},"int n-into-int 3":{"cat_title":"INT n, INTO, INT 3","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"INT n, INTO, INT 3","title":"INT n, INTO, INT 3s (Intel x86/64 assembly instruction)"},"invd":{"cat_title":"INVD","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"INVD","title":"INVD (Intel x86/64 assembly instruction)"},"invlpg":{"cat_title":"INVLPG","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"INVLPG","title":"INVLPG (Intel x86/64 assembly instruction)"},"invpcid":{"cat_title":"INVPCID","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"INVPCID","title":"INVPCID (Intel x86/64 assembly instruction)"},"iret-iretd":{"cat_title":"IRET, IRETD","path":"/X86-64 명령어 레퍼런스/I","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"IRET, IRETD","title":"IRET, IRETDs (Intel x86/64 assembly instruction)"},"jcc":{"cat_title":"Jcc","path":"/X86-64 명령어 레퍼런스/J","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"Jcc","title":"Jcc (Intel x86/64 assembly instruction)"},"jmp":{"cat_title":"JMP","path":"/X86-64 명령어 레퍼런스/J","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"JMP","title":"JMP (Intel x86/64 assembly instruction)"},"kaddw-kaddb-kaddq-kaddd":{"cat_title":"KADDW, KADDB, KADDQ, KADDD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KADDW, KADDB, KADDQ, KADDD","title":"KADDW, KADDB, KADDQ, KADDDs (Intel x86/64 assembly instruction)"},"kandnw-kandnb-kandnq-kandnd":{"cat_title":"KANDNW, KANDNB, KANDNQ, KANDND","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KANDNW, KANDNB, KANDNQ, KANDND","title":"KANDNW, KANDNB, KANDNQ, KANDNDs (Intel x86/64 assembly instruction)"},"kandw-kandb-kandq-kandd":{"cat_title":"KANDW, KANDB, KANDQ, KANDD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KANDW, KANDB, KANDQ, KANDD","title":"KANDW, KANDB, KANDQ, KANDDs (Intel x86/64 assembly instruction)"},"kmovw-kmovb-kmovq-kmovd":{"cat_title":"KMOVW, KMOVB, KMOVQ, KMOVD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KMOVW, KMOVB, KMOVQ, KMOVD","title":"KMOVW, KMOVB, KMOVQ, KMOVDs (Intel x86/64 assembly instruction)"},"knotw-knotb-knotq-knotd":{"cat_title":"KNOTW, KNOTB, KNOTQ, KNOTD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KNOTW, KNOTB, KNOTQ, KNOTD","title":"KNOTW, KNOTB, KNOTQ, KNOTDs (Intel x86/64 assembly instruction)"},"kortestw-kortestb-kortestq-kortestd":{"cat_title":"KORTESTW, KORTESTB, KORTESTQ, KORTESTD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KORTESTW, KORTESTB, KORTESTQ, KORTESTD","title":"KORTESTW, KORTESTB, KORTESTQ, KORTESTDs (Intel x86/64 assembly instruction)"},"korw-korb-korq-kord":{"cat_title":"KORW, KORB, KORQ, KORD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KORW, KORB, KORQ, KORD","title":"KORW, KORB, KORQ, KORDs (Intel x86/64 assembly instruction)"},"kshiftlw-kshiftlb-kshiftlq-kshiftld":{"cat_title":"KSHIFTLW, KSHIFTLB, KSHIFTLQ, KSHIFTLD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KSHIFTLW, KSHIFTLB, KSHIFTLQ, KSHIFTLD","title":"KSHIFTLW, KSHIFTLB, KSHIFTLQ, KSHIFTLDs (Intel x86/64 assembly instruction)"},"kshiftrw-kshiftrb-kshiftrq-kshiftrd":{"cat_title":"KSHIFTRW, KSHIFTRB, KSHIFTRQ, KSHIFTRD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KSHIFTRW, KSHIFTRB, KSHIFTRQ, KSHIFTRD","title":"KSHIFTRW, KSHIFTRB, KSHIFTRQ, KSHIFTRDs (Intel x86/64 assembly instruction)"},"ktestw-ktestb-ktestq-ktestd":{"cat_title":"KTESTW, KTESTB, KTESTQ, KTESTD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KTESTW, KTESTB, KTESTQ, KTESTD","title":"KTESTW, KTESTB, KTESTQ, KTESTDs (Intel x86/64 assembly instruction)"},"kunpckbw-kunpckwd-kunpckdq":{"cat_title":"KUNPCKBW, KUNPCKWD, KUNPCKDQ","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KUNPCKBW, KUNPCKWD, KUNPCKDQ","title":"KUNPCKBW, KUNPCKWD, KUNPCKDQs (Intel x86/64 assembly instruction)"},"kxnorw-kxnorb-kxnorq-kxnord":{"cat_title":"KXNORW, KXNORB, KXNORQ, KXNORD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KXNORW, KXNORB, KXNORQ, KXNORD","title":"KXNORW, KXNORB, KXNORQ, KXNORDs (Intel x86/64 assembly instruction)"},"kxorw-kxorb-kxorq-kxord":{"cat_title":"KXORW, KXORB, KXORQ, KXORD","path":"/X86-64 명령어 레퍼런스/K","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"KXORW, KXORB, KXORQ, KXORD","title":"KXORW, KXORB, KXORQ, KXORDs (Intel x86/64 assembly instruction)"},"lahf":{"cat_title":"LAHF","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LAHF","title":"LAHF (Intel x86/64 assembly instruction)"},"lar":{"cat_title":"LAR","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LAR","title":"LAR (Intel x86/64 assembly instruction)"},"lddqu":{"cat_title":"LDDQU","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LDDQU","title":"LDDQU (Intel x86/64 assembly instruction)"},"ldmxcsr":{"cat_title":"LDMXCSR","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LDMXCSR","title":"LDMXCSR (Intel x86/64 assembly instruction)"},"lds-les-lfs-lgs-lss":{"cat_title":"LDS, LES, LFS, LGS, LSS","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LDS, LES, LFS, LGS, LSS","title":"LDS, LES, LFS, LGS, LSSs (Intel x86/64 assembly instruction)"},"lea":{"cat_title":"LEA","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LEA","title":"LEA (Intel x86/64 assembly instruction)"},"leave":{"cat_title":"LEAVE","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LEAVE","title":"LEAVE (Intel x86/64 assembly instruction)"},"lfence":{"cat_title":"LFENCE","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LFENCE","title":"LFENCE (Intel x86/64 assembly instruction)"},"lgdt-lidt":{"cat_title":"LGDT, LIDT","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LGDT, LIDT","title":"LGDT, LIDTs (Intel x86/64 assembly instruction)"},"lldt":{"cat_title":"LLDT","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LLDT","title":"LLDT (Intel x86/64 assembly instruction)"},"lmsw":{"cat_title":"LMSW","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LMSW","title":"LMSW (Intel x86/64 assembly instruction)"},"lock":{"cat_title":"LOCK","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LOCK","title":"LOCK (Intel x86/64 assembly instruction)"},"lods-lodsb-lodsw-lodsd-lodsq":{"cat_title":"LODS, LODSB, LODSW, LODSD, LODSQ","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LODS, LODSB, LODSW, LODSD, LODSQ","title":"LODS, LODSB, LODSW, LODSD, LODSQs (Intel x86/64 assembly instruction)"},"loop-loopcc":{"cat_title":"LOOP, LOOPcc","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LOOP, LOOPcc","title":"LOOP, LOOPccs (Intel x86/64 assembly instruction)"},"lsl":{"cat_title":"LSL","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LSL","title":"LSL (Intel x86/64 assembly instruction)"},"ltr":{"cat_title":"LTR","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LTR","title":"LTR (Intel x86/64 assembly instruction)"},"lzcnt":{"cat_title":"LZCNT","path":"/X86-64 명령어 레퍼런스/L","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"LZCNT","title":"LZCNT (Intel x86/64 assembly instruction)"},"maskmovdqu":{"cat_title":"MASKMOVDQU","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MASKMOVDQU","title":"MASKMOVDQU (Intel x86/64 assembly instruction)"},"maskmovq":{"cat_title":"MASKMOVQ","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MASKMOVQ","title":"MASKMOVQ (Intel x86/64 assembly instruction)"},"maxpd":{"cat_title":"MAXPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MAXPD","title":"MAXPD (Intel x86/64 assembly instruction)"},"maxps":{"cat_title":"MAXPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MAXPS","title":"MAXPS (Intel x86/64 assembly instruction)"},"maxsd":{"cat_title":"MAXSD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MAXSD","title":"MAXSD (Intel x86/64 assembly instruction)"},"maxss":{"cat_title":"MAXSS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MAXSS","title":"MAXSS (Intel x86/64 assembly instruction)"},"mfence":{"cat_title":"MFENCE","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MFENCE","title":"MFENCE (Intel x86/64 assembly instruction)"},"minpd":{"cat_title":"MINPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MINPD","title":"MINPD (Intel x86/64 assembly instruction)"},"minps":{"cat_title":"MINPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MINPS","title":"MINPS (Intel x86/64 assembly instruction)"},"minsd":{"cat_title":"MINSD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MINSD","title":"MINSD (Intel x86/64 assembly instruction)"},"minss":{"cat_title":"MINSS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MINSS","title":"MINSS (Intel x86/64 assembly instruction)"},"monitor":{"cat_title":"MONITOR","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MONITOR","title":"MONITOR (Intel x86/64 assembly instruction)"},"mov":{"cat_title":"MOV","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOV","title":"MOV (Intel x86/64 assembly instruction)"},"mov_1":{"cat_title":"MOV","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOV","title":"MOV (Intel x86/64 assembly instruction)"},"mov_2":{"cat_title":"MOV","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOV","title":"MOV (Intel x86/64 assembly instruction)"},"movapd":{"cat_title":"MOVAPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVAPD","title":"MOVAPD (Intel x86/64 assembly instruction)"},"movaps":{"cat_title":"MOVAPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVAPS","title":"MOVAPS (Intel x86/64 assembly instruction)"},"movbe":{"cat_title":"MOVBE","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVBE","title":"MOVBE (Intel x86/64 assembly instruction)"},"movd-movq":{"cat_title":"MOVD, MOVQ","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVD, MOVQ","title":"MOVD, MOVQs (Intel x86/64 assembly instruction)"},"movddup":{"cat_title":"MOVDDUP","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVDDUP","title":"MOVDDUP (Intel x86/64 assembly instruction)"},"movdq2q":{"cat_title":"MOVDQ2Q","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVDQ2Q","title":"MOVDQ2Q (Intel x86/64 assembly instruction)"},"movdqa-vmovdqa32-vmovdqa64":{"cat_title":"MOVDQA, VMOVDQA32, VMOVDQA64","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVDQA, VMOVDQA32, VMOVDQA64","title":"MOVDQA, VMOVDQA32, VMOVDQA64s (Intel x86/64 assembly instruction)"},"movdqu-vmovdqu8-vmovdqu16-vmovdqu32-vmovdqu64":{"cat_title":"MOVDQU, VMOVDQU8, VMOVDQU16, VMOVDQU32, VMOVDQU64","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVDQU, VMOVDQU8, VMOVDQU16, VMOVDQU32, VMOVDQU64","title":"MOVDQU, VMOVDQU8, VMOVDQU16, VMOVDQU32, VMOVDQU64s (Intel x86/64 assembly instruction)"},"movhlps":{"cat_title":"MOVHLPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVHLPS","title":"MOVHLPS (Intel x86/64 assembly instruction)"},"movhpd":{"cat_title":"MOVHPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVHPD","title":"MOVHPD (Intel x86/64 assembly instruction)"},"movhps":{"cat_title":"MOVHPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVHPS","title":"MOVHPS (Intel x86/64 assembly instruction)"},"movlhps":{"cat_title":"MOVLHPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVLHPS","title":"MOVLHPS (Intel x86/64 assembly instruction)"},"movlpd":{"cat_title":"MOVLPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVLPD","title":"MOVLPD (Intel x86/64 assembly instruction)"},"movlps":{"cat_title":"MOVLPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVLPS","title":"MOVLPS (Intel x86/64 assembly instruction)"},"movmskpd":{"cat_title":"MOVMSKPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVMSKPD","title":"MOVMSKPD (Intel x86/64 assembly instruction)"},"movmskps":{"cat_title":"MOVMSKPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVMSKPS","title":"MOVMSKPS (Intel x86/64 assembly instruction)"},"movntdq":{"cat_title":"MOVNTDQ","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVNTDQ","title":"MOVNTDQ (Intel x86/64 assembly instruction)"},"movntdqa":{"cat_title":"MOVNTDQA","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVNTDQA","title":"MOVNTDQA (Intel x86/64 assembly instruction)"},"movnti":{"cat_title":"MOVNTI","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVNTI","title":"MOVNTI (Intel x86/64 assembly instruction)"},"movntpd":{"cat_title":"MOVNTPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVNTPD","title":"MOVNTPD (Intel x86/64 assembly instruction)"},"movntps":{"cat_title":"MOVNTPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVNTPS","title":"MOVNTPS (Intel x86/64 assembly instruction)"},"movntq":{"cat_title":"MOVNTQ","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVNTQ","title":"MOVNTQ (Intel x86/64 assembly instruction)"},"movq":{"cat_title":"MOVQ","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVQ","title":"MOVQ (Intel x86/64 assembly instruction)"},"movq2dq":{"cat_title":"MOVQ2DQ","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVQ2DQ","title":"MOVQ2DQ (Intel x86/64 assembly instruction)"},"movs-movsb-movsw-movsd-movsq":{"cat_title":"MOVS, MOVSB, MOVSW, MOVSD, MOVSQ","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVS, MOVSB, MOVSW, MOVSD, MOVSQ","title":"MOVS, MOVSB, MOVSW, MOVSD, MOVSQs (Intel x86/64 assembly instruction)"},"movsd":{"cat_title":"MOVSD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVSD","title":"MOVSD (Intel x86/64 assembly instruction)"},"movshdup":{"cat_title":"MOVSHDUP","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVSHDUP","title":"MOVSHDUP (Intel x86/64 assembly instruction)"},"movsldup":{"cat_title":"MOVSLDUP","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVSLDUP","title":"MOVSLDUP (Intel x86/64 assembly instruction)"},"movss":{"cat_title":"MOVSS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVSS","title":"MOVSS (Intel x86/64 assembly instruction)"},"movsx-movsxd":{"cat_title":"MOVSX, MOVSXD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVSX, MOVSXD","title":"MOVSX, MOVSXDs (Intel x86/64 assembly instruction)"},"movupd":{"cat_title":"MOVUPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVUPD","title":"MOVUPD (Intel x86/64 assembly instruction)"},"movups":{"cat_title":"MOVUPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVUPS","title":"MOVUPS (Intel x86/64 assembly instruction)"},"movzx":{"cat_title":"MOVZX","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MOVZX","title":"MOVZX (Intel x86/64 assembly instruction)"},"mpsadbw":{"cat_title":"MPSADBW","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MPSADBW","title":"MPSADBW (Intel x86/64 assembly instruction)"},"mul":{"cat_title":"MUL","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MUL","title":"MUL (Intel x86/64 assembly instruction)"},"mulpd":{"cat_title":"MULPD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MULPD","title":"MULPD (Intel x86/64 assembly instruction)"},"mulps":{"cat_title":"MULPS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MULPS","title":"MULPS (Intel x86/64 assembly instruction)"},"mulsd":{"cat_title":"MULSD","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MULSD","title":"MULSD (Intel x86/64 assembly instruction)"},"mulss":{"cat_title":"MULSS","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MULSS","title":"MULSS (Intel x86/64 assembly instruction)"},"mulx":{"cat_title":"MULX","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MULX","title":"MULX (Intel x86/64 assembly instruction)"},"mwait":{"cat_title":"MWAIT","path":"/X86-64 명령어 레퍼런스/M","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"MWAIT","title":"MWAIT (Intel x86/64 assembly instruction)"},"neg":{"cat_title":"NEG","path":"/X86-64 명령어 레퍼런스/N","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"NEG","title":"NEG (Intel x86/64 assembly instruction)"},"nop":{"cat_title":"NOP","path":"/X86-64 명령어 레퍼런스/N","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"NOP","title":"NOP (Intel x86/64 assembly instruction)"},"not":{"cat_title":"NOT","path":"/X86-64 명령어 레퍼런스/N","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"NOT","title":"NOT (Intel x86/64 assembly instruction)"},"or":{"cat_title":"OR","path":"/X86-64 명령어 레퍼런스/O","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"OR","title":"OR (Intel x86/64 assembly instruction)"},"orpd":{"cat_title":"ORPD","path":"/X86-64 명령어 레퍼런스/O","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ORPD","title":"ORPD (Intel x86/64 assembly instruction)"},"orps":{"cat_title":"ORPS","path":"/X86-64 명령어 레퍼런스/O","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ORPS","title":"ORPS (Intel x86/64 assembly instruction)"},"out":{"cat_title":"OUT","path":"/X86-64 명령어 레퍼런스/O","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"OUT","title":"OUT (Intel x86/64 assembly instruction)"},"outs-outsb-outsw-outsd":{"cat_title":"OUTS, OUTSB, OUTSW, OUTSD","path":"/X86-64 명령어 레퍼런스/O","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"OUTS, OUTSB, OUTSW, OUTSD","title":"OUTS, OUTSB, OUTSW, OUTSDs (Intel x86/64 assembly instruction)"},"pabsb-pabsw-pabsd-pabsq":{"cat_title":"PABSB, PABSW, PABSD, PABSQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PABSB, PABSW, PABSD, PABSQ","title":"PABSB, PABSW, PABSD, PABSQs (Intel x86/64 assembly instruction)"},"packsswb-packssdw":{"cat_title":"PACKSSWB, PACKSSDW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PACKSSWB, PACKSSDW","title":"PACKSSWB, PACKSSDWs (Intel x86/64 assembly instruction)"},"packusdw":{"cat_title":"PACKUSDW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PACKUSDW","title":"PACKUSDW (Intel x86/64 assembly instruction)"},"packuswb":{"cat_title":"PACKUSWB","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PACKUSWB","title":"PACKUSWB (Intel x86/64 assembly instruction)"},"paddb-paddw-paddd-paddq":{"cat_title":"PADDB, PADDW, PADDD, PADDQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PADDB, PADDW, PADDD, PADDQ","title":"PADDB, PADDW, PADDD, PADDQs (Intel x86/64 assembly instruction)"},"paddsb-paddsw":{"cat_title":"PADDSB, PADDSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PADDSB, PADDSW","title":"PADDSB, PADDSWs (Intel x86/64 assembly instruction)"},"paddusb-paddusw":{"cat_title":"PADDUSB, PADDUSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PADDUSB, PADDUSW","title":"PADDUSB, PADDUSWs (Intel x86/64 assembly instruction)"},"palignr":{"cat_title":"PALIGNR","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PALIGNR","title":"PALIGNR (Intel x86/64 assembly instruction)"},"pand":{"cat_title":"PAND","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PAND","title":"PAND (Intel x86/64 assembly instruction)"},"pandn":{"cat_title":"PANDN","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PANDN","title":"PANDN (Intel x86/64 assembly instruction)"},"pause":{"cat_title":"PAUSE","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PAUSE","title":"PAUSE (Intel x86/64 assembly instruction)"},"pavgb-pavgw":{"cat_title":"PAVGB, PAVGW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PAVGB, PAVGW","title":"PAVGB, PAVGWs (Intel x86/64 assembly instruction)"},"pblendvb":{"cat_title":"PBLENDVB","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PBLENDVB","title":"PBLENDVB (Intel x86/64 assembly instruction)"},"pblendw":{"cat_title":"PBLENDW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PBLENDW","title":"PBLENDW (Intel x86/64 assembly instruction)"},"pcmpeqb-pcmpeqw-pcmpeqd":{"cat_title":"PCMPEQB, PCMPEQW, PCMPEQD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PCMPEQB, PCMPEQW, PCMPEQD","title":"PCMPEQB, PCMPEQW, PCMPEQDs (Intel x86/64 assembly instruction)"},"pcmpeqq":{"cat_title":"PCMPEQQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PCMPEQQ","title":"PCMPEQQ (Intel x86/64 assembly instruction)"},"pcmpestri":{"cat_title":"PCMPESTRI","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PCMPESTRI","title":"PCMPESTRI (Intel x86/64 assembly instruction)"},"pcmpestrm":{"cat_title":"PCMPESTRM","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PCMPESTRM","title":"PCMPESTRM (Intel x86/64 assembly instruction)"},"pcmpgtb-pcmpgtw-pcmpgtd":{"cat_title":"PCMPGTB, PCMPGTW, PCMPGTD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PCMPGTB, PCMPGTW, PCMPGTD","title":"PCMPGTB, PCMPGTW, PCMPGTDs (Intel x86/64 assembly instruction)"},"pcmpgtq":{"cat_title":"PCMPGTQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PCMPGTQ","title":"PCMPGTQ (Intel x86/64 assembly instruction)"},"pcmpistri":{"cat_title":"PCMPISTRI","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PCMPISTRI","title":"PCMPISTRI (Intel x86/64 assembly instruction)"},"pcmpistrm":{"cat_title":"PCMPISTRM","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PCMPISTRM","title":"PCMPISTRM (Intel x86/64 assembly instruction)"},"pdep":{"cat_title":"PDEP","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PDEP","title":"PDEP (Intel x86/64 assembly instruction)"},"pext":{"cat_title":"PEXT","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PEXT","title":"PEXT (Intel x86/64 assembly instruction)"},"pextrb-pextrd-pextrq":{"cat_title":"PEXTRB, PEXTRD, PEXTRQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PEXTRB, PEXTRD, PEXTRQ","title":"PEXTRB, PEXTRD, PEXTRQs (Intel x86/64 assembly instruction)"},"pextrw":{"cat_title":"PEXTRW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PEXTRW","title":"PEXTRW (Intel x86/64 assembly instruction)"},"phaddsw":{"cat_title":"PHADDSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PHADDSW","title":"PHADDSW (Intel x86/64 assembly instruction)"},"phaddw-phaddd":{"cat_title":"PHADDW, PHADDD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PHADDW, PHADDD","title":"PHADDW, PHADDDs (Intel x86/64 assembly instruction)"},"phminposuw":{"cat_title":"PHMINPOSUW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PHMINPOSUW","title":"PHMINPOSUW (Intel x86/64 assembly instruction)"},"phsubsw":{"cat_title":"PHSUBSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PHSUBSW","title":"PHSUBSW (Intel x86/64 assembly instruction)"},"phsubw-phsubd":{"cat_title":"PHSUBW, PHSUBD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PHSUBW, PHSUBD","title":"PHSUBW, PHSUBDs (Intel x86/64 assembly instruction)"},"pinsrb-pinsrd-pinsrq":{"cat_title":"PINSRB, PINSRD, PINSRQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PINSRB, PINSRD, PINSRQ","title":"PINSRB, PINSRD, PINSRQs (Intel x86/64 assembly instruction)"},"pinsrw":{"cat_title":"PINSRW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PINSRW","title":"PINSRW (Intel x86/64 assembly instruction)"},"pmaddubsw":{"cat_title":"PMADDUBSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMADDUBSW","title":"PMADDUBSW (Intel x86/64 assembly instruction)"},"pmaddwd":{"cat_title":"PMADDWD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMADDWD","title":"PMADDWD (Intel x86/64 assembly instruction)"},"pmaxsb-pmaxsw-pmaxsd-pmaxsq":{"cat_title":"PMAXSB, PMAXSW, PMAXSD, PMAXSQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMAXSB, PMAXSW, PMAXSD, PMAXSQ","title":"PMAXSB, PMAXSW, PMAXSD, PMAXSQs (Intel x86/64 assembly instruction)"},"pmaxub-pmaxuw":{"cat_title":"PMAXUB, PMAXUW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMAXUB, PMAXUW","title":"PMAXUB, PMAXUWs (Intel x86/64 assembly instruction)"},"pmaxud-pmaxuq":{"cat_title":"PMAXUD, PMAXUQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMAXUD, PMAXUQ","title":"PMAXUD, PMAXUQs (Intel x86/64 assembly instruction)"},"pminsb-pminsw":{"cat_title":"PMINSB, PMINSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMINSB, PMINSW","title":"PMINSB, PMINSWs (Intel x86/64 assembly instruction)"},"pminsd-pminsq":{"cat_title":"PMINSD, PMINSQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMINSD, PMINSQ","title":"PMINSD, PMINSQs (Intel x86/64 assembly instruction)"},"pminub-pminuw":{"cat_title":"PMINUB, PMINUW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMINUB, PMINUW","title":"PMINUB, PMINUWs (Intel x86/64 assembly instruction)"},"pminud-pminuq":{"cat_title":"PMINUD, PMINUQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMINUD, PMINUQ","title":"PMINUD, PMINUQs (Intel x86/64 assembly instruction)"},"pmovmskb":{"cat_title":"PMOVMSKB","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMOVMSKB","title":"PMOVMSKB (Intel x86/64 assembly instruction)"},"pmovsx":{"cat_title":"PMOVSX","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMOVSX","title":"PMOVSX (Intel x86/64 assembly instruction)"},"pmovzx":{"cat_title":"PMOVZX","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMOVZX","title":"PMOVZX (Intel x86/64 assembly instruction)"},"pmuldq":{"cat_title":"PMULDQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMULDQ","title":"PMULDQ (Intel x86/64 assembly instruction)"},"pmulhrsw":{"cat_title":"PMULHRSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMULHRSW","title":"PMULHRSW (Intel x86/64 assembly instruction)"},"pmulhuw":{"cat_title":"PMULHUW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMULHUW","title":"PMULHUW (Intel x86/64 assembly instruction)"},"pmulhw":{"cat_title":"PMULHW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMULHW","title":"PMULHW (Intel x86/64 assembly instruction)"},"pmulld-pmullq":{"cat_title":"PMULLD, PMULLQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMULLD, PMULLQ","title":"PMULLD, PMULLQs (Intel x86/64 assembly instruction)"},"pmullw":{"cat_title":"PMULLW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMULLW","title":"PMULLW (Intel x86/64 assembly instruction)"},"pmuludq":{"cat_title":"PMULUDQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PMULUDQ","title":"PMULUDQ (Intel x86/64 assembly instruction)"},"pop":{"cat_title":"POP","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"POP","title":"POP (Intel x86/64 assembly instruction)"},"popa-popad":{"cat_title":"POPA, POPAD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"POPA, POPAD","title":"POPA, POPADs (Intel x86/64 assembly instruction)"},"popcnt":{"cat_title":"POPCNT","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"POPCNT","title":"POPCNT (Intel x86/64 assembly instruction)"},"popf-popfd-popfq":{"cat_title":"POPF, POPFD, POPFQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"POPF, POPFD, POPFQ","title":"POPF, POPFD, POPFQs (Intel x86/64 assembly instruction)"},"por":{"cat_title":"POR","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"POR","title":"POR (Intel x86/64 assembly instruction)"},"prefetchh":{"cat_title":"PREFETCHh","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PREFETCHh","title":"PREFETCHh (Intel x86/64 assembly instruction)"},"prefetchw":{"cat_title":"PREFETCHW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PREFETCHW","title":"PREFETCHW (Intel x86/64 assembly instruction)"},"prefetchwt1":{"cat_title":"PREFETCHWT1","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PREFETCHWT1","title":"PREFETCHWT1 (Intel x86/64 assembly instruction)"},"prold-prolvd-prolq-prolvq":{"cat_title":"PROLD, PROLVD, PROLQ, PROLVQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PROLD, PROLVD, PROLQ, PROLVQ","title":"PROLD, PROLVD, PROLQ, PROLVQs (Intel x86/64 assembly instruction)"},"prord-prorvd-prorq-prorvq":{"cat_title":"PRORD, PRORVD, PRORQ, PRORVQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PRORD, PRORVD, PRORQ, PRORVQ","title":"PRORD, PRORVD, PRORQ, PRORVQs (Intel x86/64 assembly instruction)"},"psadbw":{"cat_title":"PSADBW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSADBW","title":"PSADBW (Intel x86/64 assembly instruction)"},"pshufb":{"cat_title":"PSHUFB","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSHUFB","title":"PSHUFB (Intel x86/64 assembly instruction)"},"pshufd":{"cat_title":"PSHUFD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSHUFD","title":"PSHUFD (Intel x86/64 assembly instruction)"},"pshufhw":{"cat_title":"PSHUFHW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSHUFHW","title":"PSHUFHW (Intel x86/64 assembly instruction)"},"pshuflw":{"cat_title":"PSHUFLW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSHUFLW","title":"PSHUFLW (Intel x86/64 assembly instruction)"},"pshufw":{"cat_title":"PSHUFW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSHUFW","title":"PSHUFW (Intel x86/64 assembly instruction)"},"psignb-psignw-psignd":{"cat_title":"PSIGNB, PSIGNW, PSIGND","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSIGNB, PSIGNW, PSIGND","title":"PSIGNB, PSIGNW, PSIGNDs (Intel x86/64 assembly instruction)"},"pslldq":{"cat_title":"PSLLDQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSLLDQ","title":"PSLLDQ (Intel x86/64 assembly instruction)"},"psllw-pslld-psllq":{"cat_title":"PSLLW, PSLLD, PSLLQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSLLW, PSLLD, PSLLQ","title":"PSLLW, PSLLD, PSLLQs (Intel x86/64 assembly instruction)"},"psraw-psrad-psraq":{"cat_title":"PSRAW, PSRAD, PSRAQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSRAW, PSRAD, PSRAQ","title":"PSRAW, PSRAD, PSRAQs (Intel x86/64 assembly instruction)"},"psrldq":{"cat_title":"PSRLDQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSRLDQ","title":"PSRLDQ (Intel x86/64 assembly instruction)"},"psrlw-psrld-psrlq":{"cat_title":"PSRLW, PSRLD, PSRLQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSRLW, PSRLD, PSRLQ","title":"PSRLW, PSRLD, PSRLQs (Intel x86/64 assembly instruction)"},"psubb-psubw-psubd":{"cat_title":"PSUBB, PSUBW, PSUBD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSUBB, PSUBW, PSUBD","title":"PSUBB, PSUBW, PSUBDs (Intel x86/64 assembly instruction)"},"psubq":{"cat_title":"PSUBQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSUBQ","title":"PSUBQ (Intel x86/64 assembly instruction)"},"psubsb-psubsw":{"cat_title":"PSUBSB, PSUBSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSUBSB, PSUBSW","title":"PSUBSB, PSUBSWs (Intel x86/64 assembly instruction)"},"psubusb-psubusw":{"cat_title":"PSUBUSB, PSUBUSW","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PSUBUSB, PSUBUSW","title":"PSUBUSB, PSUBUSWs (Intel x86/64 assembly instruction)"},"punpckhbw-punpckhwd-punpckhdq-punpckhqdq":{"cat_title":"PUNPCKHBW, PUNPCKHWD, PUNPCKHDQ, PUNPCKHQDQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PUNPCKHBW, PUNPCKHWD, PUNPCKHDQ, PUNPCKHQDQ","title":"PUNPCKHBW, PUNPCKHWD, PUNPCKHDQ, PUNPCKHQDQs (Intel x86/64 assembly instruction)"},"punpcklbw-punpcklwd-punpckldq-punpcklqdq":{"cat_title":"PUNPCKLBW, PUNPCKLWD, PUNPCKLDQ, PUNPCKLQDQ","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PUNPCKLBW, PUNPCKLWD, PUNPCKLDQ, PUNPCKLQDQ","title":"PUNPCKLBW, PUNPCKLWD, PUNPCKLDQ, PUNPCKLQDQs (Intel x86/64 assembly instruction)"},"push":{"cat_title":"PUSH","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PUSH","title":"PUSH (Intel x86/64 assembly instruction)"},"pusha-pushad":{"cat_title":"PUSHA, PUSHAD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PUSHA, PUSHAD","title":"PUSHA, PUSHADs (Intel x86/64 assembly instruction)"},"pushf-pushfd":{"cat_title":"PUSHF, PUSHFD","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PUSHF, PUSHFD","title":"PUSHF, PUSHFDs (Intel x86/64 assembly instruction)"},"pxor":{"cat_title":"PXOR","path":"/X86-64 명령어 레퍼런스/P","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"PXOR","title":"PXOR (Intel x86/64 assembly instruction)"},"rcl-rcr-rol-ror":{"cat_title":"RCL, RCR, ROL, ROR","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RCL, RCR, ROL, ROR","title":"RCL, RCR, ROL, RORs (Intel x86/64 assembly instruction)"},"rcpps":{"cat_title":"RCPPS","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RCPPS","title":"RCPPS (Intel x86/64 assembly instruction)"},"rcpss":{"cat_title":"RCPSS","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RCPSS","title":"RCPSS (Intel x86/64 assembly instruction)"},"rdfsbase-rdgsbase":{"cat_title":"RDFSBASE, RDGSBASE","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDFSBASE, RDGSBASE","title":"RDFSBASE, RDGSBASEs (Intel x86/64 assembly instruction)"},"rdmsr":{"cat_title":"RDMSR","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDMSR","title":"RDMSR (Intel x86/64 assembly instruction)"},"rdpid":{"cat_title":"RDPID","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDPID","title":"RDPID (Intel x86/64 assembly instruction)"},"rdpkru":{"cat_title":"RDPKRU","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDPKRU","title":"RDPKRU (Intel x86/64 assembly instruction)"},"rdpmc":{"cat_title":"RDPMC","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDPMC","title":"RDPMC (Intel x86/64 assembly instruction)"},"rdrand":{"cat_title":"RDRAND","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDRAND","title":"RDRAND (Intel x86/64 assembly instruction)"},"rdseed":{"cat_title":"RDSEED","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDSEED","title":"RDSEED (Intel x86/64 assembly instruction)"},"rdtsc":{"cat_title":"RDTSC","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDTSC","title":"RDTSC (Intel x86/64 assembly instruction)"},"rdtscp":{"cat_title":"RDTSCP","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RDTSCP","title":"RDTSCP (Intel x86/64 assembly instruction)"},"rep-repe-repz-repne-repnz":{"cat_title":"REP, REPE, REPZ, REPNE, REPNZ","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"REP, REPE, REPZ, REPNE, REPNZ","title":"REP, REPE, REPZ, REPNE, REPNZs (Intel x86/64 assembly instruction)"},"ret":{"cat_title":"RET","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RET","title":"RET (Intel x86/64 assembly instruction)"},"rorx":{"cat_title":"RORX","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RORX","title":"RORX (Intel x86/64 assembly instruction)"},"roundpd":{"cat_title":"ROUNDPD","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ROUNDPD","title":"ROUNDPD (Intel x86/64 assembly instruction)"},"roundps":{"cat_title":"ROUNDPS","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ROUNDPS","title":"ROUNDPS (Intel x86/64 assembly instruction)"},"roundsd":{"cat_title":"ROUNDSD","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ROUNDSD","title":"ROUNDSD (Intel x86/64 assembly instruction)"},"roundss":{"cat_title":"ROUNDSS","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"ROUNDSS","title":"ROUNDSS (Intel x86/64 assembly instruction)"},"rsm":{"cat_title":"RSM","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RSM","title":"RSM (Intel x86/64 assembly instruction)"},"rsqrtps":{"cat_title":"RSQRTPS","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RSQRTPS","title":"RSQRTPS (Intel x86/64 assembly instruction)"},"rsqrtss":{"cat_title":"RSQRTSS","path":"/X86-64 명령어 레퍼런스/R","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"RSQRTSS","title":"RSQRTSS (Intel x86/64 assembly instruction)"},"sahf":{"cat_title":"SAHF","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SAHF","title":"SAHF (Intel x86/64 assembly instruction)"},"sal-sar-shl-shr":{"cat_title":"SAL, SAR, SHL, SHR","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SAL, SAR, SHL, SHR","title":"SAL, SAR, SHL, SHRs (Intel x86/64 assembly instruction)"},"sarx-shlx-shrx":{"cat_title":"SARX, SHLX, SHRX","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SARX, SHLX, SHRX","title":"SARX, SHLX, SHRXs (Intel x86/64 assembly instruction)"},"sbb":{"cat_title":"SBB","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SBB","title":"SBB (Intel x86/64 assembly instruction)"},"scas-scasb-scasw-scasd":{"cat_title":"SCAS, SCASB, SCASW, SCASD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SCAS, SCASB, SCASW, SCASD","title":"SCAS, SCASB, SCASW, SCASDs (Intel x86/64 assembly instruction)"},"setcc":{"cat_title":"SETcc","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SETcc","title":"SETcc (Intel x86/64 assembly instruction)"},"sfence":{"cat_title":"SFENCE","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SFENCE","title":"SFENCE (Intel x86/64 assembly instruction)"},"sgdt":{"cat_title":"SGDT","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SGDT","title":"SGDT (Intel x86/64 assembly instruction)"},"sha1msg1":{"cat_title":"SHA1MSG1","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHA1MSG1","title":"SHA1MSG1 (Intel x86/64 assembly instruction)"},"sha1msg2":{"cat_title":"SHA1MSG2","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHA1MSG2","title":"SHA1MSG2 (Intel x86/64 assembly instruction)"},"sha1nexte":{"cat_title":"SHA1NEXTE","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHA1NEXTE","title":"SHA1NEXTE (Intel x86/64 assembly instruction)"},"sha1rnds4":{"cat_title":"SHA1RNDS4","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHA1RNDS4","title":"SHA1RNDS4 (Intel x86/64 assembly instruction)"},"sha256msg1":{"cat_title":"SHA256MSG1","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHA256MSG1","title":"SHA256MSG1 (Intel x86/64 assembly instruction)"},"sha256msg2":{"cat_title":"SHA256MSG2","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHA256MSG2","title":"SHA256MSG2 (Intel x86/64 assembly instruction)"},"sha256rnds2":{"cat_title":"SHA256RNDS2","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHA256RNDS2","title":"SHA256RNDS2 (Intel x86/64 assembly instruction)"},"shld":{"cat_title":"SHLD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHLD","title":"SHLD (Intel x86/64 assembly instruction)"},"shrd":{"cat_title":"SHRD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHRD","title":"SHRD (Intel x86/64 assembly instruction)"},"shufpd":{"cat_title":"SHUFPD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHUFPD","title":"SHUFPD (Intel x86/64 assembly instruction)"},"shufps":{"cat_title":"SHUFPS","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SHUFPS","title":"SHUFPS (Intel x86/64 assembly instruction)"},"sidt":{"cat_title":"SIDT","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SIDT","title":"SIDT (Intel x86/64 assembly instruction)"},"sldt":{"cat_title":"SLDT","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SLDT","title":"SLDT (Intel x86/64 assembly instruction)"},"smsw":{"cat_title":"SMSW","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SMSW","title":"SMSW (Intel x86/64 assembly instruction)"},"sqrtpd":{"cat_title":"SQRTPD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SQRTPD","title":"SQRTPD (Intel x86/64 assembly instruction)"},"sqrtps":{"cat_title":"SQRTPS","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SQRTPS","title":"SQRTPS (Intel x86/64 assembly instruction)"},"sqrtsd":{"cat_title":"SQRTSD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SQRTSD","title":"SQRTSD (Intel x86/64 assembly instruction)"},"sqrtss":{"cat_title":"SQRTSS","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SQRTSS","title":"SQRTSS (Intel x86/64 assembly instruction)"},"stac":{"cat_title":"STAC","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"STAC","title":"STAC (Intel x86/64 assembly instruction)"},"stc":{"cat_title":"STC","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"STC","title":"STC (Intel x86/64 assembly instruction)"},"std":{"cat_title":"STD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"STD","title":"STD (Intel x86/64 assembly instruction)"},"sti":{"cat_title":"STI","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"STI","title":"STI (Intel x86/64 assembly instruction)"},"stmxcsr":{"cat_title":"STMXCSR","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"STMXCSR","title":"STMXCSR (Intel x86/64 assembly instruction)"},"stos-stosb-stosw-stosd-stosq":{"cat_title":"STOS, STOSB, STOSW, STOSD, STOSQ","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"STOS, STOSB, STOSW, STOSD, STOSQ","title":"STOS, STOSB, STOSW, STOSD, STOSQs (Intel x86/64 assembly instruction)"},"str":{"cat_title":"STR","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"STR","title":"STR (Intel x86/64 assembly instruction)"},"sub":{"cat_title":"SUB","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SUB","title":"SUB (Intel x86/64 assembly instruction)"},"subpd":{"cat_title":"SUBPD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SUBPD","title":"SUBPD (Intel x86/64 assembly instruction)"},"subps":{"cat_title":"SUBPS","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SUBPS","title":"SUBPS (Intel x86/64 assembly instruction)"},"subsd":{"cat_title":"SUBSD","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SUBSD","title":"SUBSD (Intel x86/64 assembly instruction)"},"subss":{"cat_title":"SUBSS","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SUBSS","title":"SUBSS (Intel x86/64 assembly instruction)"},"swapgs":{"cat_title":"SWAPGS","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SWAPGS","title":"SWAPGS (Intel x86/64 assembly instruction)"},"syscall":{"cat_title":"SYSCALL","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SYSCALL","title":"SYSCALL (Intel x86/64 assembly instruction)"},"sysenter":{"cat_title":"SYSENTER","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SYSENTER","title":"SYSENTER (Intel x86/64 assembly instruction)"},"sysexit":{"cat_title":"SYSEXIT","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SYSEXIT","title":"SYSEXIT (Intel x86/64 assembly instruction)"},"sysret":{"cat_title":"SYSRET","path":"/X86-64 명령어 레퍼런스/S","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"SYSRET","title":"SYSRET (Intel x86/64 assembly instruction)"},"test":{"cat_title":"TEST","path":"/X86-64 명령어 레퍼런스/T","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"TEST","title":"TEST (Intel x86/64 assembly instruction)"},"tzcnt":{"cat_title":"TZCNT","path":"/X86-64 명령어 레퍼런스/T","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"TZCNT","title":"TZCNT (Intel x86/64 assembly instruction)"},"ucomisd":{"cat_title":"UCOMISD","path":"/X86-64 명령어 레퍼런스/U","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"UCOMISD","title":"UCOMISD (Intel x86/64 assembly instruction)"},"ucomiss":{"cat_title":"UCOMISS","path":"/X86-64 명령어 레퍼런스/U","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"UCOMISS","title":"UCOMISS (Intel x86/64 assembly instruction)"},"ud2":{"cat_title":"UD2","path":"/X86-64 명령어 레퍼런스/U","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"UD2","title":"UD2 (Intel x86/64 assembly instruction)"},"unpckhpd":{"cat_title":"UNPCKHPD","path":"/X86-64 명령어 레퍼런스/U","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"UNPCKHPD","title":"UNPCKHPD (Intel x86/64 assembly instruction)"},"unpckhps":{"cat_title":"UNPCKHPS","path":"/X86-64 명령어 레퍼런스/U","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"UNPCKHPS","title":"UNPCKHPS (Intel x86/64 assembly instruction)"},"unpcklpd":{"cat_title":"UNPCKLPD","path":"/X86-64 명령어 레퍼런스/U","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"UNPCKLPD","title":"UNPCKLPD (Intel x86/64 assembly instruction)"},"unpcklps":{"cat_title":"UNPCKLPS","path":"/X86-64 명령어 레퍼런스/U","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"UNPCKLPS","title":"UNPCKLPS (Intel x86/64 assembly instruction)"},"valignd-valignq":{"cat_title":"VALIGND, VALIGNQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VALIGND, VALIGNQ","title":"VALIGND, VALIGNQs (Intel x86/64 assembly instruction)"},"vblendmpd-vblendmps":{"cat_title":"VBLENDMPD, VBLENDMPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VBLENDMPD, VBLENDMPS","title":"VBLENDMPD, VBLENDMPSs (Intel x86/64 assembly instruction)"},"vbroadcast":{"cat_title":"VBROADCAST","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VBROADCAST","title":"VBROADCAST (Intel x86/64 assembly instruction)"},"vcompresspd":{"cat_title":"VCOMPRESSPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCOMPRESSPD","title":"VCOMPRESSPD (Intel x86/64 assembly instruction)"},"vcompressps":{"cat_title":"VCOMPRESSPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCOMPRESSPS","title":"VCOMPRESSPS (Intel x86/64 assembly instruction)"},"vcvtpd2qq":{"cat_title":"VCVTPD2QQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTPD2QQ","title":"VCVTPD2QQ (Intel x86/64 assembly instruction)"},"vcvtpd2udq":{"cat_title":"VCVTPD2UDQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTPD2UDQ","title":"VCVTPD2UDQ (Intel x86/64 assembly instruction)"},"vcvtpd2uqq":{"cat_title":"VCVTPD2UQQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTPD2UQQ","title":"VCVTPD2UQQ (Intel x86/64 assembly instruction)"},"vcvtph2ps":{"cat_title":"VCVTPH2PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTPH2PS","title":"VCVTPH2PS (Intel x86/64 assembly instruction)"},"vcvtps2ph":{"cat_title":"VCVTPS2PH","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTPS2PH","title":"VCVTPS2PH (Intel x86/64 assembly instruction)"},"vcvtps2qq":{"cat_title":"VCVTPS2QQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTPS2QQ","title":"VCVTPS2QQ (Intel x86/64 assembly instruction)"},"vcvtps2udq":{"cat_title":"VCVTPS2UDQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTPS2UDQ","title":"VCVTPS2UDQ (Intel x86/64 assembly instruction)"},"vcvtps2uqq":{"cat_title":"VCVTPS2UQQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTPS2UQQ","title":"VCVTPS2UQQ (Intel x86/64 assembly instruction)"},"vcvtqq2pd":{"cat_title":"VCVTQQ2PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTQQ2PD","title":"VCVTQQ2PD (Intel x86/64 assembly instruction)"},"vcvtqq2ps":{"cat_title":"VCVTQQ2PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTQQ2PS","title":"VCVTQQ2PS (Intel x86/64 assembly instruction)"},"vcvtsd2usi":{"cat_title":"VCVTSD2USI","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTSD2USI","title":"VCVTSD2USI (Intel x86/64 assembly instruction)"},"vcvtss2usi":{"cat_title":"VCVTSS2USI","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTSS2USI","title":"VCVTSS2USI (Intel x86/64 assembly instruction)"},"vcvttpd2qq":{"cat_title":"VCVTTPD2QQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTTPD2QQ","title":"VCVTTPD2QQ (Intel x86/64 assembly instruction)"},"vcvttpd2udq":{"cat_title":"VCVTTPD2UDQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTTPD2UDQ","title":"VCVTTPD2UDQ (Intel x86/64 assembly instruction)"},"vcvttpd2uqq":{"cat_title":"VCVTTPD2UQQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTTPD2UQQ","title":"VCVTTPD2UQQ (Intel x86/64 assembly instruction)"},"vcvttps2qq":{"cat_title":"VCVTTPS2QQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTTPS2QQ","title":"VCVTTPS2QQ (Intel x86/64 assembly instruction)"},"vcvttps2udq":{"cat_title":"VCVTTPS2UDQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTTPS2UDQ","title":"VCVTTPS2UDQ (Intel x86/64 assembly instruction)"},"vcvttps2uqq":{"cat_title":"VCVTTPS2UQQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTTPS2UQQ","title":"VCVTTPS2UQQ (Intel x86/64 assembly instruction)"},"vcvttsd2usi":{"cat_title":"VCVTTSD2USI","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTTSD2USI","title":"VCVTTSD2USI (Intel x86/64 assembly instruction)"},"vcvttss2usi":{"cat_title":"VCVTTSS2USI","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTTSS2USI","title":"VCVTTSS2USI (Intel x86/64 assembly instruction)"},"vcvtudq2pd":{"cat_title":"VCVTUDQ2PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTUDQ2PD","title":"VCVTUDQ2PD (Intel x86/64 assembly instruction)"},"vcvtudq2ps":{"cat_title":"VCVTUDQ2PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTUDQ2PS","title":"VCVTUDQ2PS (Intel x86/64 assembly instruction)"},"vcvtuqq2pd":{"cat_title":"VCVTUQQ2PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTUQQ2PD","title":"VCVTUQQ2PD (Intel x86/64 assembly instruction)"},"vcvtuqq2ps":{"cat_title":"VCVTUQQ2PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTUQQ2PS","title":"VCVTUQQ2PS (Intel x86/64 assembly instruction)"},"vcvtusi2sd":{"cat_title":"VCVTUSI2SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTUSI2SD","title":"VCVTUSI2SD (Intel x86/64 assembly instruction)"},"vcvtusi2ss":{"cat_title":"VCVTUSI2SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VCVTUSI2SS","title":"VCVTUSI2SS (Intel x86/64 assembly instruction)"},"vdbpsadbw":{"cat_title":"VDBPSADBW","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VDBPSADBW","title":"VDBPSADBW (Intel x86/64 assembly instruction)"},"verr-verw":{"cat_title":"VERR, VERW","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VERR, VERW","title":"VERR, VERWs (Intel x86/64 assembly instruction)"},"vexp2pd":{"cat_title":"VEXP2PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VEXP2PD","title":"VEXP2PD (Intel x86/64 assembly instruction)"},"vexp2ps":{"cat_title":"VEXP2PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VEXP2PS","title":"VEXP2PS (Intel x86/64 assembly instruction)"},"vexpandpd":{"cat_title":"VEXPANDPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VEXPANDPD","title":"VEXPANDPD (Intel x86/64 assembly instruction)"},"vexpandps":{"cat_title":"VEXPANDPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VEXPANDPS","title":"VEXPANDPS (Intel x86/64 assembly instruction)"},"vextractf128-vextractf32x4-vextractf64x2-vextractf32x8-vextractf64x4":{"cat_title":"VEXTRACTF128, VEXTRACTF32x4, VEXTRACTF64x2, VEXTRACTF32x8, VEXTRACTF64x4","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VEXTRACTF128, VEXTRACTF32x4, VEXTRACTF64x2, VEXTRACTF32x8, VEXTRACTF64x4","title":"VEXTRACTF128, VEXTRACTF32x4, VEXTRACTF64x2, VEXTRACTF32x8, VEXTRACTF64x4s (Intel x86/64 assembly instruction)"},"vextracti128-vextracti32x4-vextracti64x2-vextracti32x8-vextracti64x4":{"cat_title":"VEXTRACTI128, VEXTRACTI32x4, VEXTRACTI64x2, VEXTRACTI32x8, VEXTRACTI64x4","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VEXTRACTI128, VEXTRACTI32x4, VEXTRACTI64x2, VEXTRACTI32x8, VEXTRACTI64x4","title":"VEXTRACTI128, VEXTRACTI32x4, VEXTRACTI64x2, VEXTRACTI32x8, VEXTRACTI64x4s (Intel x86/64 assembly instruction)"},"vfixupimmpd":{"cat_title":"VFIXUPIMMPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFIXUPIMMPD","title":"VFIXUPIMMPD (Intel x86/64 assembly instruction)"},"vfixupimmps":{"cat_title":"VFIXUPIMMPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFIXUPIMMPS","title":"VFIXUPIMMPS (Intel x86/64 assembly instruction)"},"vfixupimmsd":{"cat_title":"VFIXUPIMMSD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFIXUPIMMSD","title":"VFIXUPIMMSD (Intel x86/64 assembly instruction)"},"vfixupimmss":{"cat_title":"VFIXUPIMMSS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFIXUPIMMSS","title":"VFIXUPIMMSS (Intel x86/64 assembly instruction)"},"vfmadd132pd-vfmadd213pd-vfmadd231pd":{"cat_title":"VFMADD132PD, VFMADD213PD, VFMADD231PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMADD132PD, VFMADD213PD, VFMADD231PD","title":"VFMADD132PD, VFMADD213PD, VFMADD231PDs (Intel x86/64 assembly instruction)"},"vfmadd132ps-vfmadd213ps-vfmadd231ps":{"cat_title":"VFMADD132PS, VFMADD213PS, VFMADD231PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMADD132PS, VFMADD213PS, VFMADD231PS","title":"VFMADD132PS, VFMADD213PS, VFMADD231PSs (Intel x86/64 assembly instruction)"},"vfmadd132sd-vfmadd213sd-vfmadd231sd":{"cat_title":"VFMADD132SD, VFMADD213SD, VFMADD231SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMADD132SD, VFMADD213SD, VFMADD231SD","title":"VFMADD132SD, VFMADD213SD, VFMADD231SDs (Intel x86/64 assembly instruction)"},"vfmadd132ss-vfmadd213ss-vfmadd231ss":{"cat_title":"VFMADD132SS, VFMADD213SS, VFMADD231SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMADD132SS, VFMADD213SS, VFMADD231SS","title":"VFMADD132SS, VFMADD213SS, VFMADD231SSs (Intel x86/64 assembly instruction)"},"vfmaddsub132pd-vfmaddsub213pd-vfmaddsub231pd":{"cat_title":"VFMADDSUB132PD, VFMADDSUB213PD, VFMADDSUB231PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMADDSUB132PD, VFMADDSUB213PD, VFMADDSUB231PD","title":"VFMADDSUB132PD, VFMADDSUB213PD, VFMADDSUB231PDs (Intel x86/64 assembly instruction)"},"vfmaddsub132ps-vfmaddsub213ps-vfmaddsub231ps":{"cat_title":"VFMADDSUB132PS, VFMADDSUB213PS, VFMADDSUB231PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMADDSUB132PS, VFMADDSUB213PS, VFMADDSUB231PS","title":"VFMADDSUB132PS, VFMADDSUB213PS, VFMADDSUB231PSs (Intel x86/64 assembly instruction)"},"vfmsub132pd-vfmsub213pd-vfmsub231pd":{"cat_title":"VFMSUB132PD, VFMSUB213PD, VFMSUB231PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMSUB132PD, VFMSUB213PD, VFMSUB231PD","title":"VFMSUB132PD, VFMSUB213PD, VFMSUB231PDs (Intel x86/64 assembly instruction)"},"vfmsub132ps-vfmsub213ps-vfmsub231ps":{"cat_title":"VFMSUB132PS, VFMSUB213PS, VFMSUB231PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMSUB132PS, VFMSUB213PS, VFMSUB231PS","title":"VFMSUB132PS, VFMSUB213PS, VFMSUB231PSs (Intel x86/64 assembly instruction)"},"vfmsub132sd-vfmsub213sd-vfmsub231sd":{"cat_title":"VFMSUB132SD, VFMSUB213SD, VFMSUB231SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMSUB132SD, VFMSUB213SD, VFMSUB231SD","title":"VFMSUB132SD, VFMSUB213SD, VFMSUB231SDs (Intel x86/64 assembly instruction)"},"vfmsub132ss-vfmsub213ss-vfmsub231ss":{"cat_title":"VFMSUB132SS, VFMSUB213SS, VFMSUB231SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMSUB132SS, VFMSUB213SS, VFMSUB231SS","title":"VFMSUB132SS, VFMSUB213SS, VFMSUB231SSs (Intel x86/64 assembly instruction)"},"vfmsubadd132pd-vfmsubadd213pd-vfmsubadd231pd":{"cat_title":"VFMSUBADD132PD, VFMSUBADD213PD, VFMSUBADD231PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMSUBADD132PD, VFMSUBADD213PD, VFMSUBADD231PD","title":"VFMSUBADD132PD, VFMSUBADD213PD, VFMSUBADD231PDs (Intel x86/64 assembly instruction)"},"vfmsubadd132ps-vfmsubadd213ps-vfmsubadd231ps":{"cat_title":"VFMSUBADD132PS, VFMSUBADD213PS, VFMSUBADD231PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFMSUBADD132PS, VFMSUBADD213PS, VFMSUBADD231PS","title":"VFMSUBADD132PS, VFMSUBADD213PS, VFMSUBADD231PSs (Intel x86/64 assembly instruction)"},"vfnmadd132pd-vfnmadd213pd-vfnmadd231pd":{"cat_title":"VFNMADD132PD, VFNMADD213PD, VFNMADD231PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFNMADD132PD, VFNMADD213PD, VFNMADD231PD","title":"VFNMADD132PD, VFNMADD213PD, VFNMADD231PDs (Intel x86/64 assembly instruction)"},"vfnmadd132ps-vfnmadd213ps-vfnmadd231ps":{"cat_title":"VFNMADD132PS, VFNMADD213PS, VFNMADD231PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFNMADD132PS, VFNMADD213PS, VFNMADD231PS","title":"VFNMADD132PS, VFNMADD213PS, VFNMADD231PSs (Intel x86/64 assembly instruction)"},"vfnmadd132sd-vfnmadd213sd-vfnmadd231sd":{"cat_title":"VFNMADD132SD, VFNMADD213SD, VFNMADD231SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFNMADD132SD, VFNMADD213SD, VFNMADD231SD","title":"VFNMADD132SD, VFNMADD213SD, VFNMADD231SDs (Intel x86/64 assembly instruction)"},"vfnmadd132ss-vfnmadd213ss-vfnmadd231ss":{"cat_title":"VFNMADD132SS, VFNMADD213SS, VFNMADD231SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFNMADD132SS, VFNMADD213SS, VFNMADD231SS","title":"VFNMADD132SS, VFNMADD213SS, VFNMADD231SSs (Intel x86/64 assembly instruction)"},"vfnmsub132pd-vfnmsub213pd-vfnmsub231pd":{"cat_title":"VFNMSUB132PD, VFNMSUB213PD, VFNMSUB231PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFNMSUB132PD, VFNMSUB213PD, VFNMSUB231PD","title":"VFNMSUB132PD, VFNMSUB213PD, VFNMSUB231PDs (Intel x86/64 assembly instruction)"},"vfnmsub132ps-vfnmsub213ps-vfnmsub231ps":{"cat_title":"VFNMSUB132PS, VFNMSUB213PS, VFNMSUB231PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFNMSUB132PS, VFNMSUB213PS, VFNMSUB231PS","title":"VFNMSUB132PS, VFNMSUB213PS, VFNMSUB231PSs (Intel x86/64 assembly instruction)"},"vfnmsub132sd-vfnmsub213sd-vfnmsub231sd":{"cat_title":"VFNMSUB132SD, VFNMSUB213SD, VFNMSUB231SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFNMSUB132SD, VFNMSUB213SD, VFNMSUB231SD","title":"VFNMSUB132SD, VFNMSUB213SD, VFNMSUB231SDs (Intel x86/64 assembly instruction)"},"vfnmsub132ss-vfnmsub213ss-vfnmsub231ss":{"cat_title":"VFNMSUB132SS, VFNMSUB213SS, VFNMSUB231SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFNMSUB132SS, VFNMSUB213SS, VFNMSUB231SS","title":"VFNMSUB132SS, VFNMSUB213SS, VFNMSUB231SSs (Intel x86/64 assembly instruction)"},"vfpclasspd":{"cat_title":"VFPCLASSPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFPCLASSPD","title":"VFPCLASSPD (Intel x86/64 assembly instruction)"},"vfpclassps":{"cat_title":"VFPCLASSPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFPCLASSPS","title":"VFPCLASSPS (Intel x86/64 assembly instruction)"},"vfpclasssd":{"cat_title":"VFPCLASSSD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFPCLASSSD","title":"VFPCLASSSD (Intel x86/64 assembly instruction)"},"vfpclassss":{"cat_title":"VFPCLASSSS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VFPCLASSSS","title":"VFPCLASSSS (Intel x86/64 assembly instruction)"},"vgatherdpd-vgatherqpd":{"cat_title":"VGATHERDPD, VGATHERQPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGATHERDPD, VGATHERQPD","title":"VGATHERDPD, VGATHERQPDs (Intel x86/64 assembly instruction)"},"vgatherdps-vgatherdpd":{"cat_title":"VGATHERDPS, VGATHERDPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGATHERDPS, VGATHERDPD","title":"VGATHERDPS, VGATHERDPDs (Intel x86/64 assembly instruction)"},"vgatherdps-vgatherqps":{"cat_title":"VGATHERDPS, VGATHERQPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGATHERDPS, VGATHERQPS","title":"VGATHERDPS, VGATHERQPSs (Intel x86/64 assembly instruction)"},"vgatherpf0dps-vgatherpf0qps-vgatherpf0dpd-vgatherpf0qpd":{"cat_title":"VGATHERPF0DPS, VGATHERPF0QPS, VGATHERPF0DPD, VGATHERPF0QPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGATHERPF0DPS, VGATHERPF0QPS, VGATHERPF0DPD, VGATHERPF0QPD","title":"VGATHERPF0DPS, VGATHERPF0QPS, VGATHERPF0DPD, VGATHERPF0QPDs (Intel x86/64 assembly instruction)"},"vgatherpf1dps-vgatherpf1qps-vgatherpf1dpd-vgatherpf1qpd":{"cat_title":"VGATHERPF1DPS, VGATHERPF1QPS, VGATHERPF1DPD, VGATHERPF1QPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGATHERPF1DPS, VGATHERPF1QPS, VGATHERPF1DPD, VGATHERPF1QPD","title":"VGATHERPF1DPS, VGATHERPF1QPS, VGATHERPF1DPD, VGATHERPF1QPDs (Intel x86/64 assembly instruction)"},"vgatherqps-vgatherqpd":{"cat_title":"VGATHERQPS, VGATHERQPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGATHERQPS, VGATHERQPD","title":"VGATHERQPS, VGATHERQPDs (Intel x86/64 assembly instruction)"},"vgetexppd":{"cat_title":"VGETEXPPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGETEXPPD","title":"VGETEXPPD (Intel x86/64 assembly instruction)"},"vgetexpps":{"cat_title":"VGETEXPPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGETEXPPS","title":"VGETEXPPS (Intel x86/64 assembly instruction)"},"vgetexpsd":{"cat_title":"VGETEXPSD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGETEXPSD","title":"VGETEXPSD (Intel x86/64 assembly instruction)"},"vgetexpss":{"cat_title":"VGETEXPSS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGETEXPSS","title":"VGETEXPSS (Intel x86/64 assembly instruction)"},"vgetmantpd":{"cat_title":"VGETMANTPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGETMANTPD","title":"VGETMANTPD (Intel x86/64 assembly instruction)"},"vgetmantps":{"cat_title":"VGETMANTPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGETMANTPS","title":"VGETMANTPS (Intel x86/64 assembly instruction)"},"vgetmantsd":{"cat_title":"VGETMANTSD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGETMANTSD","title":"VGETMANTSD (Intel x86/64 assembly instruction)"},"vgetmantss":{"cat_title":"VGETMANTSS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VGETMANTSS","title":"VGETMANTSS (Intel x86/64 assembly instruction)"},"vinsertf128-vinsertf32x4-vinsertf64x2-vinsertf32x8-vinsertf64x4":{"cat_title":"VINSERTF128, VINSERTF32x4, VINSERTF64x2, VINSERTF32x8, VINSERTF64x4","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VINSERTF128, VINSERTF32x4, VINSERTF64x2, VINSERTF32x8, VINSERTF64x4","title":"VINSERTF128, VINSERTF32x4, VINSERTF64x2, VINSERTF32x8, VINSERTF64x4s (Intel x86/64 assembly instruction)"},"vinserti128-vinserti32x4-vinserti64x2-vinserti32x8-vinserti64x4":{"cat_title":"VINSERTI128, VINSERTI32x4, VINSERTI64x2, VINSERTI32x8, VINSERTI64x4","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VINSERTI128, VINSERTI32x4, VINSERTI64x2, VINSERTI32x8, VINSERTI64x4","title":"VINSERTI128, VINSERTI32x4, VINSERTI64x2, VINSERTI32x8, VINSERTI64x4s (Intel x86/64 assembly instruction)"},"vmaskmov":{"cat_title":"VMASKMOV","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VMASKMOV","title":"VMASKMOV (Intel x86/64 assembly instruction)"},"vpblendd":{"cat_title":"VPBLENDD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPBLENDD","title":"VPBLENDD (Intel x86/64 assembly instruction)"},"vpblendmb-vpblendmw":{"cat_title":"VPBLENDMB, VPBLENDMW","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPBLENDMB, VPBLENDMW","title":"VPBLENDMB, VPBLENDMWs (Intel x86/64 assembly instruction)"},"vpblendmd-vpblendmq":{"cat_title":"VPBLENDMD, VPBLENDMQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPBLENDMD, VPBLENDMQ","title":"VPBLENDMD, VPBLENDMQs (Intel x86/64 assembly instruction)"},"vpbroadcast":{"cat_title":"VPBROADCAST","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPBROADCAST","title":"VPBROADCAST (Intel x86/64 assembly instruction)"},"vpbroadcastb-vpbroadcastw-vpbroadcastd-vpbroadcastq":{"cat_title":"VPBROADCASTB, VPBROADCASTW, VPBROADCASTD, VPBROADCASTQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPBROADCASTB, VPBROADCASTW, VPBROADCASTD, VPBROADCASTQ","title":"VPBROADCASTB, VPBROADCASTW, VPBROADCASTD, VPBROADCASTQs (Intel x86/64 assembly instruction)"},"vpbroadcastm":{"cat_title":"VPBROADCASTM","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPBROADCASTM","title":"VPBROADCASTM (Intel x86/64 assembly instruction)"},"vpcmpb-vpcmpub":{"cat_title":"VPCMPB, VPCMPUB","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPCMPB, VPCMPUB","title":"VPCMPB, VPCMPUBs (Intel x86/64 assembly instruction)"},"vpcmpd-vpcmpud":{"cat_title":"VPCMPD, VPCMPUD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPCMPD, VPCMPUD","title":"VPCMPD, VPCMPUDs (Intel x86/64 assembly instruction)"},"vpcmpq-vpcmpuq":{"cat_title":"VPCMPQ, VPCMPUQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPCMPQ, VPCMPUQ","title":"VPCMPQ, VPCMPUQs (Intel x86/64 assembly instruction)"},"vpcmpw-vpcmpuw":{"cat_title":"VPCMPW, VPCMPUW","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPCMPW, VPCMPUW","title":"VPCMPW, VPCMPUWs (Intel x86/64 assembly instruction)"},"vpcompressd":{"cat_title":"VPCOMPRESSD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPCOMPRESSD","title":"VPCOMPRESSD (Intel x86/64 assembly instruction)"},"vpcompressq":{"cat_title":"VPCOMPRESSQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPCOMPRESSQ","title":"VPCOMPRESSQ (Intel x86/64 assembly instruction)"},"vpconflictd-vpconflictq":{"cat_title":"VPCONFLICTD, VPCONFLICTQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPCONFLICTD, VPCONFLICTQ","title":"VPCONFLICTD, VPCONFLICTQs (Intel x86/64 assembly instruction)"},"vperm2f128":{"cat_title":"VPERM2F128","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERM2F128","title":"VPERM2F128 (Intel x86/64 assembly instruction)"},"vperm2i128":{"cat_title":"VPERM2I128","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERM2I128","title":"VPERM2I128 (Intel x86/64 assembly instruction)"},"vpermd-vpermw":{"cat_title":"VPERMD, VPERMW","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERMD, VPERMW","title":"VPERMD, VPERMWs (Intel x86/64 assembly instruction)"},"vpermi2w-vpermi2d-vpermi2q-vpermi2ps-vpermi2pd":{"cat_title":"VPERMI2W, VPERMI2D, VPERMI2Q, VPERMI2PS, VPERMI2PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERMI2W, VPERMI2D, VPERMI2Q, VPERMI2PS, VPERMI2PD","title":"VPERMI2W, VPERMI2D, VPERMI2Q, VPERMI2PS, VPERMI2PDs (Intel x86/64 assembly instruction)"},"vpermilpd":{"cat_title":"VPERMILPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERMILPD","title":"VPERMILPD (Intel x86/64 assembly instruction)"},"vpermilps":{"cat_title":"VPERMILPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERMILPS","title":"VPERMILPS (Intel x86/64 assembly instruction)"},"vpermpd":{"cat_title":"VPERMPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERMPD","title":"VPERMPD (Intel x86/64 assembly instruction)"},"vpermps":{"cat_title":"VPERMPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERMPS","title":"VPERMPS (Intel x86/64 assembly instruction)"},"vpermq":{"cat_title":"VPERMQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPERMQ","title":"VPERMQ (Intel x86/64 assembly instruction)"},"vpexpandd":{"cat_title":"VPEXPANDD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPEXPANDD","title":"VPEXPANDD (Intel x86/64 assembly instruction)"},"vpexpandq":{"cat_title":"VPEXPANDQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPEXPANDQ","title":"VPEXPANDQ (Intel x86/64 assembly instruction)"},"vpgatherdd-vpgatherdq":{"cat_title":"VPGATHERDD, VPGATHERDQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPGATHERDD, VPGATHERDQ","title":"VPGATHERDD, VPGATHERDQs (Intel x86/64 assembly instruction)"},"vpgatherdd-vpgatherqd":{"cat_title":"VPGATHERDD, VPGATHERQD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPGATHERDD, VPGATHERQD","title":"VPGATHERDD, VPGATHERQDs (Intel x86/64 assembly instruction)"},"vpgatherdq-vpgatherqq":{"cat_title":"VPGATHERDQ, VPGATHERQQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPGATHERDQ, VPGATHERQQ","title":"VPGATHERDQ, VPGATHERQQs (Intel x86/64 assembly instruction)"},"vpgatherqd-vpgatherqq":{"cat_title":"VPGATHERQD, VPGATHERQQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPGATHERQD, VPGATHERQQ","title":"VPGATHERQD, VPGATHERQQs (Intel x86/64 assembly instruction)"},"vplzcntd-vplzcntq":{"cat_title":"VPLZCNTD, VPLZCNTQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPLZCNTD, VPLZCNTQ","title":"VPLZCNTD, VPLZCNTQs (Intel x86/64 assembly instruction)"},"vpmaskmov":{"cat_title":"VPMASKMOV","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMASKMOV","title":"VPMASKMOV (Intel x86/64 assembly instruction)"},"vpmovb2m-vpmovw2m-vpmovd2m-vpmovq2m":{"cat_title":"VPMOVB2M, VPMOVW2M, VPMOVD2M, VPMOVQ2M","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMOVB2M, VPMOVW2M, VPMOVD2M, VPMOVQ2M","title":"VPMOVB2M, VPMOVW2M, VPMOVD2M, VPMOVQ2Ms (Intel x86/64 assembly instruction)"},"vpmovdb-vpmovsdb-vpmovusdb":{"cat_title":"VPMOVDB, VPMOVSDB, VPMOVUSDB","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMOVDB, VPMOVSDB, VPMOVUSDB","title":"VPMOVDB, VPMOVSDB, VPMOVUSDBs (Intel x86/64 assembly instruction)"},"vpmovdw-vpmovsdw-vpmovusdw":{"cat_title":"VPMOVDW, VPMOVSDW, VPMOVUSDW","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMOVDW, VPMOVSDW, VPMOVUSDW","title":"VPMOVDW, VPMOVSDW, VPMOVUSDWs (Intel x86/64 assembly instruction)"},"vpmovm2b-vpmovm2w-vpmovm2d-vpmovm2q":{"cat_title":"VPMOVM2B, VPMOVM2W, VPMOVM2D, VPMOVM2Q","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMOVM2B, VPMOVM2W, VPMOVM2D, VPMOVM2Q","title":"VPMOVM2B, VPMOVM2W, VPMOVM2D, VPMOVM2Qs (Intel x86/64 assembly instruction)"},"vpmovqb-vpmovsqb-vpmovusqb":{"cat_title":"VPMOVQB, VPMOVSQB, VPMOVUSQB","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMOVQB, VPMOVSQB, VPMOVUSQB","title":"VPMOVQB, VPMOVSQB, VPMOVUSQBs (Intel x86/64 assembly instruction)"},"vpmovqd-vpmovsqd-vpmovusqd":{"cat_title":"VPMOVQD, VPMOVSQD, VPMOVUSQD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMOVQD, VPMOVSQD, VPMOVUSQD","title":"VPMOVQD, VPMOVSQD, VPMOVUSQDs (Intel x86/64 assembly instruction)"},"vpmovqw-vpmovsqw-vpmovusqw":{"cat_title":"VPMOVQW, VPMOVSQW, VPMOVUSQW","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMOVQW, VPMOVSQW, VPMOVUSQW","title":"VPMOVQW, VPMOVSQW, VPMOVUSQWs (Intel x86/64 assembly instruction)"},"vpmovwb-vpmovswb-vpmovuswb":{"cat_title":"VPMOVWB, VPMOVSWB, VPMOVUSWB","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPMOVWB, VPMOVSWB, VPMOVUSWB","title":"VPMOVWB, VPMOVSWB, VPMOVUSWBs (Intel x86/64 assembly instruction)"},"vpscatterdd-vpscatterdq-vpscatterqd-vpscatterqq":{"cat_title":"VPSCATTERDD, VPSCATTERDQ, VPSCATTERQD, VPSCATTERQQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPSCATTERDD, VPSCATTERDQ, VPSCATTERQD, VPSCATTERQQ","title":"VPSCATTERDD, VPSCATTERDQ, VPSCATTERQD, VPSCATTERQQs (Intel x86/64 assembly instruction)"},"vpsllvw-vpsllvd-vpsllvq":{"cat_title":"VPSLLVW, VPSLLVD, VPSLLVQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPSLLVW, VPSLLVD, VPSLLVQ","title":"VPSLLVW, VPSLLVD, VPSLLVQs (Intel x86/64 assembly instruction)"},"vpsravw-vpsravd-vpsravq":{"cat_title":"VPSRAVW, VPSRAVD, VPSRAVQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPSRAVW, VPSRAVD, VPSRAVQ","title":"VPSRAVW, VPSRAVD, VPSRAVQs (Intel x86/64 assembly instruction)"},"vpsrlvw-vpsrlvd-vpsrlvq":{"cat_title":"VPSRLVW, VPSRLVD, VPSRLVQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPSRLVW, VPSRLVD, VPSRLVQ","title":"VPSRLVW, VPSRLVD, VPSRLVQs (Intel x86/64 assembly instruction)"},"vpternlogd-vpternlogq":{"cat_title":"VPTERNLOGD, VPTERNLOGQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPTERNLOGD, VPTERNLOGQ","title":"VPTERNLOGD, VPTERNLOGQs (Intel x86/64 assembly instruction)"},"vptestmb-vptestmw-vptestmd-vptestmq":{"cat_title":"VPTESTMB, VPTESTMW, VPTESTMD, VPTESTMQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPTESTMB, VPTESTMW, VPTESTMD, VPTESTMQ","title":"VPTESTMB, VPTESTMW, VPTESTMD, VPTESTMQs (Intel x86/64 assembly instruction)"},"vptestnmb-vptestnmw-vptestnmd-vptestnmq":{"cat_title":"VPTESTNMB, VPTESTNMW, VPTESTNMD, VPTESTNMQ","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VPTESTNMB, VPTESTNMW, VPTESTNMD, VPTESTNMQ","title":"VPTESTNMB, VPTESTNMW, VPTESTNMD, VPTESTNMQs (Intel x86/64 assembly instruction)"},"vrangepd":{"cat_title":"VRANGEPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRANGEPD","title":"VRANGEPD (Intel x86/64 assembly instruction)"},"vrangesd":{"cat_title":"VRANGESD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRANGESD","title":"VRANGESD (Intel x86/64 assembly instruction)"},"vrangess":{"cat_title":"VRANGESS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRANGESS","title":"VRANGESS (Intel x86/64 assembly instruction)"},"vrcp14pd":{"cat_title":"VRCP14PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRCP14PD","title":"VRCP14PD (Intel x86/64 assembly instruction)"},"vrcp14ps":{"cat_title":"VRCP14PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRCP14PS","title":"VRCP14PS (Intel x86/64 assembly instruction)"},"vrcp14sd":{"cat_title":"VRCP14SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRCP14SD","title":"VRCP14SD (Intel x86/64 assembly instruction)"},"vrcp14ss":{"cat_title":"VRCP14SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRCP14SS","title":"VRCP14SS (Intel x86/64 assembly instruction)"},"vrcp28pd":{"cat_title":"VRCP28PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRCP28PD","title":"VRCP28PD (Intel x86/64 assembly instruction)"},"vrcp28ps":{"cat_title":"VRCP28PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRCP28PS","title":"VRCP28PS (Intel x86/64 assembly instruction)"},"vrcp28sd":{"cat_title":"VRCP28SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRCP28SD","title":"VRCP28SD (Intel x86/64 assembly instruction)"},"vrcp28ss":{"cat_title":"VRCP28SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRCP28SS","title":"VRCP28SS (Intel x86/64 assembly instruction)"},"vreducepd":{"cat_title":"VREDUCEPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VREDUCEPD","title":"VREDUCEPD (Intel x86/64 assembly instruction)"},"vreduceps":{"cat_title":"VREDUCEPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VREDUCEPS","title":"VREDUCEPS (Intel x86/64 assembly instruction)"},"vreducess":{"cat_title":"VREDUCESS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VREDUCESS","title":"VREDUCESS (Intel x86/64 assembly instruction)"},"vrndscalepd":{"cat_title":"VRNDSCALEPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRNDSCALEPD","title":"VRNDSCALEPD (Intel x86/64 assembly instruction)"},"vrndscaleps":{"cat_title":"VRNDSCALEPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRNDSCALEPS","title":"VRNDSCALEPS (Intel x86/64 assembly instruction)"},"vrndscalesd":{"cat_title":"VRNDSCALESD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRNDSCALESD","title":"VRNDSCALESD (Intel x86/64 assembly instruction)"},"vrndscaless":{"cat_title":"VRNDSCALESS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRNDSCALESS","title":"VRNDSCALESS (Intel x86/64 assembly instruction)"},"vrsqrt14pd":{"cat_title":"VRSQRT14PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRSQRT14PD","title":"VRSQRT14PD (Intel x86/64 assembly instruction)"},"vrsqrt14ps":{"cat_title":"VRSQRT14PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRSQRT14PS","title":"VRSQRT14PS (Intel x86/64 assembly instruction)"},"vrsqrt14sd":{"cat_title":"VRSQRT14SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRSQRT14SD","title":"VRSQRT14SD (Intel x86/64 assembly instruction)"},"vrsqrt14ss":{"cat_title":"VRSQRT14SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRSQRT14SS","title":"VRSQRT14SS (Intel x86/64 assembly instruction)"},"vrsqrt28pd":{"cat_title":"VRSQRT28PD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRSQRT28PD","title":"VRSQRT28PD (Intel x86/64 assembly instruction)"},"vrsqrt28ps":{"cat_title":"VRSQRT28PS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRSQRT28PS","title":"VRSQRT28PS (Intel x86/64 assembly instruction)"},"vrsqrt28sd":{"cat_title":"VRSQRT28SD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRSQRT28SD","title":"VRSQRT28SD (Intel x86/64 assembly instruction)"},"vrsqrt28ss":{"cat_title":"VRSQRT28SS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VRSQRT28SS","title":"VRSQRT28SS (Intel x86/64 assembly instruction)"},"vscalefpd":{"cat_title":"VSCALEFPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VSCALEFPD","title":"VSCALEFPD (Intel x86/64 assembly instruction)"},"vscalefps":{"cat_title":"VSCALEFPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VSCALEFPS","title":"VSCALEFPS (Intel x86/64 assembly instruction)"},"vscalefsd":{"cat_title":"VSCALEFSD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VSCALEFSD","title":"VSCALEFSD (Intel x86/64 assembly instruction)"},"vscalefss":{"cat_title":"VSCALEFSS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VSCALEFSS","title":"VSCALEFSS (Intel x86/64 assembly instruction)"},"vscatterdps-vscatterdpd-vscatterqps-vscatterqpd":{"cat_title":"VSCATTERDPS, VSCATTERDPD, VSCATTERQPS, VSCATTERQPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VSCATTERDPS, VSCATTERDPD, VSCATTERQPS, VSCATTERQPD","title":"VSCATTERDPS, VSCATTERDPD, VSCATTERQPS, VSCATTERQPDs (Intel x86/64 assembly instruction)"},"vscatterpf0dps-vscatterpf0qps-vscatterpf0dpd-vscatterpf0qpd":{"cat_title":"VSCATTERPF0DPS, VSCATTERPF0QPS, VSCATTERPF0DPD, VSCATTERPF0QPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VSCATTERPF0DPS, VSCATTERPF0QPS, VSCATTERPF0DPD, VSCATTERPF0QPD","title":"VSCATTERPF0DPS, VSCATTERPF0QPS, VSCATTERPF0DPD, VSCATTERPF0QPDs (Intel x86/64 assembly instruction)"},"vscatterpf1dps-vscatterpf1qps-vscatterpf1dpd-vscatterpf1qpd":{"cat_title":"VSCATTERPF1DPS, VSCATTERPF1QPS, VSCATTERPF1DPD, VSCATTERPF1QPD","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VSCATTERPF1DPS, VSCATTERPF1QPS, VSCATTERPF1DPD, VSCATTERPF1QPD","title":"VSCATTERPF1DPS, VSCATTERPF1QPS, VSCATTERPF1DPD, VSCATTERPF1QPDs (Intel x86/64 assembly instruction)"},"vshuff32x4-vshuff64x2-vshufi32x4-vshufi64x2":{"cat_title":"VSHUFF32x4, VSHUFF64x2, VSHUFI32x4, VSHUFI64x2","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VSHUFF32x4, VSHUFF64x2, VSHUFI32x4, VSHUFI64x2","title":"VSHUFF32x4, VSHUFF64x2, VSHUFI32x4, VSHUFI64x2s (Intel x86/64 assembly instruction)"},"vtestpd-vtestps":{"cat_title":"VTESTPD, VTESTPS","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VTESTPD, VTESTPS","title":"VTESTPD, VTESTPSs (Intel x86/64 assembly instruction)"},"vzeroall":{"cat_title":"VZEROALL","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VZEROALL","title":"VZEROALL (Intel x86/64 assembly instruction)"},"vzeroupper":{"cat_title":"VZEROUPPER","path":"/X86-64 명령어 레퍼런스/V","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"VZEROUPPER","title":"VZEROUPPER (Intel x86/64 assembly instruction)"},"wait-fwait":{"cat_title":"WAIT, FWAIT","path":"/X86-64 명령어 레퍼런스/W","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"WAIT, FWAIT","title":"WAIT, FWAITs (Intel x86/64 assembly instruction)"},"wbinvd":{"cat_title":"WBINVD","path":"/X86-64 명령어 레퍼런스/W","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"WBINVD","title":"WBINVD (Intel x86/64 assembly instruction)"},"wrfsbase-wrgsbase":{"cat_title":"WRFSBASE, WRGSBASE","path":"/X86-64 명령어 레퍼런스/W","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"WRFSBASE, WRGSBASE","title":"WRFSBASE, WRGSBASEs (Intel x86/64 assembly instruction)"},"wrmsr":{"cat_title":"WRMSR","path":"/X86-64 명령어 레퍼런스/W","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"WRMSR","title":"WRMSR (Intel x86/64 assembly instruction)"},"wrpkru":{"cat_title":"WRPKRU","path":"/X86-64 명령어 레퍼런스/W","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"WRPKRU","title":"WRPKRU (Intel x86/64 assembly instruction)"},"xabort":{"cat_title":"XABORT","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XABORT","title":"XABORT (Intel x86/64 assembly instruction)"},"xacquire-xrelease":{"cat_title":"XACQUIRE, XRELEASE","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XACQUIRE, XRELEASE","title":"XACQUIRE, XRELEASEs (Intel x86/64 assembly instruction)"},"xadd":{"cat_title":"XADD","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XADD","title":"XADD (Intel x86/64 assembly instruction)"},"xbegin":{"cat_title":"XBEGIN","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XBEGIN","title":"XBEGIN (Intel x86/64 assembly instruction)"},"xchg":{"cat_title":"XCHG","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XCHG","title":"XCHG (Intel x86/64 assembly instruction)"},"xend":{"cat_title":"XEND","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XEND","title":"XEND (Intel x86/64 assembly instruction)"},"xgetbv":{"cat_title":"XGETBV","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XGETBV","title":"XGETBV (Intel x86/64 assembly instruction)"},"xlat-xlatb":{"cat_title":"XLAT, XLATB","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XLAT, XLATB","title":"XLAT, XLATBs (Intel x86/64 assembly instruction)"},"xor":{"cat_title":"XOR","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XOR","title":"XOR (Intel x86/64 assembly instruction)"},"xorpd":{"cat_title":"XORPD","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XORPD","title":"XORPD (Intel x86/64 assembly instruction)"},"xorps":{"cat_title":"XORPS","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XORPS","title":"XORPS (Intel x86/64 assembly instruction)"},"xrstor":{"cat_title":"XRSTOR","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XRSTOR","title":"XRSTOR (Intel x86/64 assembly instruction)"},"xrstors":{"cat_title":"XRSTORS","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XRSTORS","title":"XRSTORS (Intel x86/64 assembly instruction)"},"xsave":{"cat_title":"XSAVE","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XSAVE","title":"XSAVE (Intel x86/64 assembly instruction)"},"xsavec":{"cat_title":"XSAVEC","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XSAVEC","title":"XSAVEC (Intel x86/64 assembly instruction)"},"xsaveopt":{"cat_title":"XSAVEOPT","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XSAVEOPT","title":"XSAVEOPT (Intel x86/64 assembly instruction)"},"xsaves":{"cat_title":"XSAVES","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XSAVES","title":"XSAVES (Intel x86/64 assembly instruction)"},"xsetbv":{"cat_title":"XSETBV","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XSETBV","title":"XSETBV (Intel x86/64 assembly instruction)"},"xtest":{"cat_title":"XTEST","path":"/X86-64 명령어 레퍼런스/X","publish_date":"2020-09-01","published":"2020-09-01","ref_title":"XTEST","title":"XTEST (Intel x86/64 assembly instruction)"}}