fcml_common.hpp

Go to the documentation of this file.

/*
 * FCML - Free Code Manipulation Library.
 * Copyright (C) 2010-2020 Slawomir Wojtasiak
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef FCML_COMMON_HPP_
#define FCML_COMMON_HPP_

#include <stdlib.h>
#include <string.h>
#include <new>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <memory>
#include <vector>

#include "fcml_types.h"
#include "fcml_common.h"
#include "fcml_common_utils.h"
#include "fcml_errors.h"

namespace fcml {

#define FCML_TO_CPP_BOOL( x ) ( (x) ? true : false )

typedef std::basic_string<fcml_char> fcml_cstring;

typedef std::basic_ostringstream<fcml_char> fcml_costream;

class Env {
public:
    static fcml_string strDup( const fcml_string str ) {
        if ( !str ) {
            return NULL;
        }
#if defined(FCML_MSCC)
        fcml_string newStr = _strdup( str );
#else
        fcml_string newStr = strdup( str );
#endif
        if ( !newStr ) {
            throw std::bad_alloc();
        }
        return newStr;
    }
    static void strFree( fcml_string str ) {
        free( str );
    }
};

template <typename T>
class Iterator {
public:

    Iterator() {}

    virtual ~Iterator() {}

    virtual bool hasNext() = 0;

    virtual T next() = 0;
};

template<typename T>
class Nullable {
public:

    Nullable( const T& value, bool is_not_null = true ) :
        _value( value ), _is_not_null( is_not_null ) {
    }

    Nullable() :
        _is_not_null( false ) {
    }

    bool isNotNull() const {
        return _is_not_null;
    }

    void setNotNull(bool isNull) {
        _is_not_null = isNull;
    }

    T getValue() const {
        return _value;
    }

    T& getValue() {
        return _value;
    }

    void setValue(const T& value) {
        this->_value = value;
    }

public:

    bool operator==(const Nullable &nullable) const {
        return _value == nullable._value &&
                _is_not_null == nullable._is_not_null;
    }

    bool operator!=(const Nullable &nullable) const {
        return !(nullable == *this);
    }

private:
    T _value;
    bool _is_not_null;
};

class BaseException {
public:
    BaseException( fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) {
        this->_error = error;
    }
    BaseException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) {
        this->_msg = msg;
        this->_error = error;
    }
    BaseException( const BaseException &cpy ) {
        this->_msg = cpy._msg;
        this->_error = cpy._error;
    }
    virtual ~BaseException() {
    }
    BaseException& operator=( const BaseException &exc ) {
        if ( &exc != this ) {
            this->_msg = exc._msg;
            this->_error = exc._error;
        }
        return *this;
    }
public:
    const fcml_cstring getMsg() const {
        return _msg;
    }
    const fcml_ceh_error& getError() const {
        return _error;
    }
private:
    void* operator new( size_t size ) {
        return ::operator new( size );
    }
private:
    fcml_cstring _msg;
    fcml_ceh_error _error;
};

class InitException: public BaseException {
public:
    InitException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) :
            BaseException( msg, error ) {
    }
};

class BadArgumentException: public BaseException {
public:
    BadArgumentException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) :
            BaseException( msg, error ) {
    }
};

class IllegalStateException: public BaseException {
public:
    IllegalStateException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) :
            BaseException( msg, error ) {
    }
};

class IllegalArgumentException: public BaseException {
public:
    IllegalArgumentException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) :
            BaseException( msg, error ) {
    }
};

class OperationNotSupportedException: public BaseException {
public:
    OperationNotSupportedException( const fcml_cstring &msg ) :
            BaseException( msg ) {
    }
    OperationNotSupportedException() {
    }
};

class NonCopyable {
protected:
    NonCopyable() {
    }
private:
    NonCopyable( const NonCopyable &cpy ) {
        throw OperationNotSupportedException();
    }
    NonCopyable& operator=( const NonCopyable &exc ) {
        throw OperationNotSupportedException();
    }
};

class InstructionPrefix {
private:
    static InstructionPrefix create( fcml_prefixes prefix ) {
        InstructionPrefix instructionPrefix;
        instructionPrefix._prefix = prefix;
        return instructionPrefix;
    }
public:
    static const InstructionPrefix LOCK() {
        return create(FCML_PREFIX_LOCK);
    }
    static const InstructionPrefix REPNE() {
        return create(FCML_PREFIX_REPNE);
    }
    static const InstructionPrefix REPNZ() {
        return create(FCML_PREFIX_REPNZ);
    }
    static const InstructionPrefix REP() {
        return create(FCML_PREFIX_REP);
    }
    static const InstructionPrefix REPE() {
        return create(FCML_PREFIX_REPE);
    }
    static const InstructionPrefix REPZ() {
        return create(FCML_PREFIX_REPZ);
    }
    static const InstructionPrefix XACQUIRE() {
        return create(FCML_PREFIX_XACQUIRE);
    }
    static const InstructionPrefix XRELEASE() {
        return create(FCML_PREFIX_XRELEASE);
    }
    static const InstructionPrefix BRANCH_HINT() {
        return create(FCML_PREFIX_BRANCH_HINT);
    }
    static const InstructionPrefix NOBRANCH_HINT() {
        return create(FCML_PREFIX_NOBRANCH_HINT);
    }
public:
    fcml_prefixes _prefix;
};

struct InstructionHint {
private:
    InstructionHint(fcml_en_instruction_hints hints) :
        _hint(hints) {
    }
public:
    static const InstructionHint NO_HINTS() {
        return InstructionHint(FCML_HINT_NO_HINTS);
    }
    static const InstructionHint NEAR_POINTER() {
        return InstructionHint(FCML_HINT_NEAR_POINTER);
    }
    static const InstructionHint FAR_POINTER() {
        return InstructionHint(FCML_HINT_FAR_POINTER);
    }
    static const InstructionHint LONG_FORM_POINTER() {
        return InstructionHint(FCML_HINT_LONG_FORM_POINTER);
    }
    static const InstructionHint INDIRECT_POINTER() {
        return InstructionHint(FCML_HINT_INDIRECT_POINTER);
    }
    static const InstructionHint DIRECT_POINTER() {
        return InstructionHint(FCML_HINT_DIRECT_POINTER);
    }
public:
    fcml_en_instruction_hints _hint;
};

struct OperandHint {
private:
    OperandHint(fcml_en_operand_hints hint) :
        _hint(hint) {
    }
public:
    static const OperandHint UNDEFIEND() {
        return OperandHint(FCML_OP_HINT_UNDEFIEND);
    }
    static const OperandHint MULTIMEDIA() {
        return OperandHint(FCML_OP_HINT_MULTIMEDIA_INSTRUCTION);
    }
    static const OperandHint DISPLACEMENT_RELATIVE_ADDRESS() {
        return OperandHint(FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS);
    }
    static const OperandHint PSEUDO_OPCODE() {
        return OperandHint(FCML_OP_HINT_PSEUDO_OPCODE);
    }
    static const OperandHint ABSOLUTE_ADDRESSING() {
        return OperandHint(FCML_OP_HINT_ABSOLUTE_ADDRESSING);
    }
    static const OperandHint RELATIVE_ADDRESSING() {
        return OperandHint(FCML_OP_HINT_RELATIVE_ADDRESSING);
    }
    static const OperandHint SIB_ENCODING() {
        return OperandHint(FCML_OP_HINT_SIB_ENCODING);
    }
public:
    fcml_en_operand_hints _hint;
};

class EntryPoint {
public:

    enum OperatingMode {
        OM_16_BIT = FCML_OM_16_BIT,
        OM_32_BIT = FCML_OM_32_BIT,
        OM_64_BIT = FCML_OM_64_BIT
    };

    EntryPoint() :
        _opMode(OM_32_BIT),
        _addressSizeAttribute(FCML_DS_32),
        _operandSizeAttribute(FCML_DS_32),
        _ip(0) {
    }

    EntryPoint(OperatingMode opMode, fcml_ip ip = 0, fcml_usize addressSizeAttribute = FCML_DS_UNDEF, fcml_usize operandSizeAttribute = FCML_DS_UNDEF ) :
        _opMode(opMode),
        _addressSizeAttribute(addressSizeAttribute),
        _operandSizeAttribute(operandSizeAttribute),
        _ip(ip) {
    }

    virtual ~EntryPoint() {
    }

public:

    bool operator==( const EntryPoint &ep ) const {
        return _opMode == ep._opMode &&
                _ip == ep._ip &&
                _operandSizeAttribute == ep._operandSizeAttribute &&
                _addressSizeAttribute == ep._addressSizeAttribute;
    }

    bool operator!=( const EntryPoint &ep ) const {
        return !(ep == *this);
    }

public:

    fcml_usize getAddressSizeAttribute() const {
        return _addressSizeAttribute;
    }

    void setAddressSizeAttribute( fcml_usize addressSizeAttribute ) {
       _addressSizeAttribute = addressSizeAttribute;
    }

    fcml_usize getOperandSizeAttribute() const {
        return _operandSizeAttribute;
    }

    void setOperandSizeAttribute( fcml_usize operandSizeAttribute ) {
       _operandSizeAttribute = operandSizeAttribute;
    }

    fcml_ip getIP() const {
       return _ip;
    }

    void setIP( fcml_ip ip ) {
       _ip = ip;
    }

    OperatingMode getOpMode() const {
       return _opMode;
    }

    void setOpMode( OperatingMode opMode ) {
       _opMode = opMode;
    }

    void incrementIP( fcml_ip ip ) {
        _ip += ip;
    }

private:
    OperatingMode _opMode;
    fcml_usize _addressSizeAttribute;
    fcml_usize _operandSizeAttribute;
    fcml_ip _ip;
};

class Integer {
public:

    Integer() :
            _size( FCML_DS_64 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) {
    }

    Integer( fcml_int8_t value ) :
            _size( FCML_DS_8 ), _isSigned( FCML_TRUE ), _vint8( value ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) {
    }

    Integer( fcml_int16_t value ) :
            _size( FCML_DS_16 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( value ), _vint32( 0 ), _vint64( 0 ) {
    }

    Integer( fcml_int32_t value ) :
            _size( FCML_DS_32 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( 0 ), _vint32( value ), _vint64( 0 ) {
    }

    Integer( fcml_int64_t value ) :
            _size( FCML_DS_64 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( value ) {
    }

    Integer( fcml_uint8_t value ) :
            _size( FCML_DS_8 ), _isSigned( FCML_FALSE ), _vint8( static_cast<fcml_uint8_t>( value ) ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) {
    }

    Integer( fcml_uint16_t value ) :
            _size( FCML_DS_16 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( static_cast<fcml_uint16_t>( value ) ), _vint32( 0 ), _vint64( 0 ) {
    }

    Integer( fcml_uint32_t value ) :
            _size( FCML_DS_32 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( static_cast<fcml_uint32_t>( value ) ), _vint64( 0 ) {
    }

    Integer( fcml_uint64_t value ) :
            _size( FCML_DS_64 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( static_cast<fcml_uint64_t>( value ) ) {
    }

    virtual ~Integer() {
    }

public:

    fcml_int16_t getInt16() const {
        return _vint16;
    }

    Integer& setInt16( fcml_int16_t int16 ) {
        _vint16 = int16;
        return *this;
    }

    fcml_int32_t getInt32() const {
        return _vint32;
    }

    Integer& setInt32( fcml_int32_t int32 ) {
        _vint32 = int32;
        return *this;
    }

    fcml_int64_t getInt64() const {
        return _vint64;
    }

    Integer& setInt64( fcml_int64_t int64 ) {
        _vint64 = int64;
        return *this;
    }

    fcml_int8_t getInt8() const {
        return _vint8;
    }

    Integer& setInt8( fcml_int8_t int8 ) {
        _vint8 = int8;
        return *this;
    }

    fcml_bool isSigned() const {
        return _isSigned;
    }

    Integer& setSigned( fcml_bool isSigned ) {
        _isSigned = isSigned;
        return *this;
    }

    fcml_usize getSize() const {
        return _size;
    }

    Integer& setSize( fcml_usize size ) {
        _size = size;
        return *this;
    }

    bool operator==( const fcml_uint8_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator==( const fcml_int8_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator==( const fcml_uint16_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator==( const fcml_int16_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator==( const fcml_uint32_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator==( const fcml_int32_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator==( const fcml_uint64_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator==( const fcml_int64_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator==( const Integer &value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) == static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) == static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const fcml_uint8_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const fcml_int8_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const fcml_uint16_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const fcml_int16_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const fcml_uint32_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const fcml_int32_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const fcml_uint64_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const fcml_int64_t value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    bool operator!=( const Integer &value ) const {
        return _isSigned ? static_cast<fcml_int64_t>( *this ) != static_cast<fcml_int64_t>( value ) : static_cast<fcml_uint64_t>( *this ) != static_cast<fcml_uint64_t>( value );
    }

    operator fcml_int8_t() const {
        fcml_int8_t result;
        switch ( _size ) {
        case FCML_DS_8:
            result = static_cast<fcml_int8_t>( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 );
            break;
        case FCML_DS_16:
            result = static_cast<fcml_int8_t>( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 );
            break;
        case FCML_DS_32:
            result = static_cast<fcml_int8_t>( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 );
            break;
        case FCML_DS_64:
            result = static_cast<fcml_int8_t>( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 );
            break;
        default:
            throw BadArgumentException( FCML_TEXT( "Wrong size." ) );
        }
        return result;
    }
    operator fcml_uint8_t() const {
        fcml_uint8_t result;
        switch ( _size ) {
        case FCML_DS_8:
            result = static_cast<fcml_uint8_t>( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 );
            break;
        case FCML_DS_16:
            result = static_cast<fcml_uint8_t>( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 );
            break;
        case FCML_DS_32:
            result = static_cast<fcml_uint8_t>( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 );
            break;
        case FCML_DS_64:
            result = static_cast<fcml_uint8_t>( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 );
            break;
        default:
            throw BadArgumentException( FCML_TEXT( "Wrong size." ) );
        }
        return result;
    }

    operator fcml_int16_t() const {
        fcml_int16_t result;
        switch ( _size ) {
        case FCML_DS_8:
            result = static_cast<fcml_int16_t>( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 );
            break;
        case FCML_DS_16:
            result = static_cast<fcml_int16_t>( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 );
            break;
        case FCML_DS_32:
            result = static_cast<fcml_int16_t>( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 );
            break;
        case FCML_DS_64:
            result = static_cast<fcml_int16_t>( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 );
            break;
        default:
            throw BadArgumentException( FCML_TEXT( "Wrong size." ) );
        }
        return result;
    }

    operator fcml_uint16_t() const {
        fcml_uint16_t result;
        switch ( _size ) {
        case FCML_DS_8:
            result = static_cast<fcml_uint16_t>( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 );
            break;
        case FCML_DS_16:
            result = static_cast<fcml_uint16_t>( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 );
            break;
        case FCML_DS_32:
            result = static_cast<fcml_uint16_t>( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 );
            break;
        case FCML_DS_64:
            result = static_cast<fcml_uint16_t>( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 );
            break;
        default:
            throw BadArgumentException( FCML_TEXT( "Wrong size." ) );
        }
        return result;
    }

    operator fcml_int32_t() const {
        fcml_int32_t result;
        switch ( _size ) {
        case FCML_DS_8:
            result = static_cast<fcml_int32_t>( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 );
            break;
        case FCML_DS_16:
            result = static_cast<fcml_int32_t>( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 );
            break;
        case FCML_DS_32:
            result = static_cast<fcml_int32_t>( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 );
            break;
        case FCML_DS_64:
            result = static_cast<fcml_int32_t>( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 );
            break;
        default:
            throw BadArgumentException( FCML_TEXT( "Wrong size." ) );
        }
        return result;
    }

    operator fcml_uint32_t() const {
        fcml_uint32_t result;
        switch ( _size ) {
        case FCML_DS_8:
            result = static_cast<fcml_uint32_t>( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 );
            break;
        case FCML_DS_16:
            result = static_cast<fcml_uint32_t>( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 );
            break;
        case FCML_DS_32:
            result = static_cast<fcml_uint32_t>( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 );
            break;
        case FCML_DS_64:
            result = static_cast<fcml_uint32_t>( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 );
            break;
        default:
            throw BadArgumentException( FCML_TEXT( "Wrong size." ) );
        }
        return result;
    }

    operator fcml_int64_t() const {
        fcml_int64_t result;
        switch ( _size ) {
        case FCML_DS_8:
            result = static_cast<fcml_int64_t>( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 );
            break;
        case FCML_DS_16:
            result = static_cast<fcml_int64_t>( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 );
            break;
        case FCML_DS_32:
            result = static_cast<fcml_int64_t>( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 );
            break;
        case FCML_DS_64:
            result = static_cast<fcml_int64_t>( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 );
            break;
        default:
            throw BadArgumentException( FCML_TEXT( "Wrong size." ) );
        }
        return result;
    }

    operator fcml_uint64_t() const {
        fcml_uint64_t result;
        switch ( _size ) {
        case FCML_DS_8:
            result = static_cast<fcml_uint64_t>( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 );
            break;
        case FCML_DS_16:
            result = static_cast<fcml_uint64_t>( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 );
            break;
        case FCML_DS_32:
            result = static_cast<fcml_uint64_t>( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 );
            break;
        case FCML_DS_64:
            result = static_cast<fcml_uint64_t>( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 );
            break;
        default:
            throw BadArgumentException( FCML_TEXT( "Wrong size." ) );
        }
        return result;
    }

    Integer& operator +=( const Integer &arg ) {
        plus( *this, arg );
        return ( *this );
    }

    Integer& operator *=( const Integer &arg ) {
        mul( *this, arg );
        return ( *this );
    }

    Integer& operator /=( const Integer &arg ) {
        div( *this, arg );
        return ( *this );
    }

    Integer& operator -=( const Integer &arg ) {
        minus( *this, arg );
        return ( *this );
    }

    Integer operator+( const Integer &src ) const {
        const Integer &thisRef = *this;
        Integer result( thisRef );
        plus( result, src );
        return result;
    }

    Integer operator-( const Integer &src ) const {
        const Integer &thisRef = *this;
        Integer result( thisRef );
        minus( result, src );
        return result;
    }

    Integer operator*( const Integer &src ) const {
        const Integer &thisRef = *this;
        Integer result( thisRef );
        mul( result, src );
        return result;
    }

    Integer operator/( const Integer &src ) const {
        const Integer &thisRef = *this;
        Integer result( thisRef );
        div( result, src );
        return result;
    }

public:

    static Integer int8( fcml_int8_t value ) {
        return Integer( value );
    }

    static Integer uint8( fcml_uint8_t value ) {
        return Integer( value );
    }

    static Integer int16( fcml_int16_t value ) {
        return Integer( value );
    }

    static Integer uint16( fcml_uint16_t value ) {
        return Integer( value );
    }

    static Integer int32( fcml_int32_t value ) {
        return Integer( value );
    }

    static Integer uint32( fcml_uint32_t value ) {
        return Integer( value );
    }

    static Integer int64( fcml_int64_t value ) {
        return Integer( value );
    }

    static Integer uint64( fcml_uint64_t value ) {
        return Integer( value );
    }

private:

    void minus( Integer &result, const Integer &src ) const {
        callMathExpression( &doMinus, &doUMinus, result, src );
    }

    void mul( Integer &result, const Integer &src ) const {
        callMathExpression( &doMul, &doUMul, result, src );
    }

    void div( Integer &result, const Integer &src ) const {
        callMathExpression( &doDiv, &doUDiv, result, src );
    }

    void plus( Integer &result, const Integer &src ) const {
        callMathExpression( &doPlus, &doUPlus, result, src );
    }

private:

    static fcml_int64_t doPlus( fcml_int64_t thisValue, fcml_int64_t thatValue ) {
        return thisValue + thatValue;
    }

    static fcml_int64_t doMinus( fcml_int64_t thisValue, fcml_int64_t thatValue ) {
        return thisValue - thatValue;
    }

    static fcml_int64_t doMul( fcml_int64_t thisValue, fcml_int64_t thatValue ) {
        return thisValue * thatValue;
    }

    static fcml_int64_t doDiv( fcml_int64_t thisValue, fcml_int64_t thatValue ) {
        return thisValue / thatValue;
    }

    static fcml_uint64_t doUPlus( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) {
        return thisValue + thatValue;
    }

    static fcml_uint64_t doUMinus( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) {
        return thisValue - thatValue;
    }

    static fcml_uint64_t doUMul( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) {
        return thisValue * thatValue;
    }

    static fcml_uint64_t doUDiv( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) {
        return thisValue / thatValue;
    }

    void callMathExpression( fcml_int64_t (*signedExpressionFn)( fcml_int64_t thisValue, fcml_int64_t thatValue ),
            fcml_uint64_t (*unsignedExpressionFn)( fcml_uint64_t thisValue, fcml_uint64_t thatValue ),
            Integer &result, const Integer &src ) const {

        if(  _isSigned ) {

            fcml_int64_t thisValue;
            fcml_int64_t thatValue;

            // Prepare "that". It has to be converted to the same sign.
            switch( src._size ) {
            case FCML_DS_8:
                thatValue = src._isSigned ? src._vint8 : static_cast<fcml_uint8_t>( src._vint8 );
                break;
            case FCML_DS_16:
                thatValue = src._isSigned ? src._vint16 : static_cast<fcml_uint16_t>( src._vint16 );
                break;
            case FCML_DS_32:
                thatValue = src._isSigned ? src._vint32 : static_cast<fcml_uint32_t>( src._vint32 );
                break;
            case FCML_DS_64:
                thatValue = src._isSigned ? src._vint64 : static_cast<fcml_uint64_t>( src._vint64 );
                break;
            }

            // Now "this".
            switch( result._size ) {
            case FCML_DS_8:
                thisValue = result._isSigned ? result._vint8 : static_cast<fcml_uint8_t>(result._vint8 );
                thisValue = (*signedExpressionFn)( thisValue, thatValue );
                result._vint8 = static_cast<fcml_int8_t>( thisValue );
                break;
            case FCML_DS_16:
                thisValue = result._isSigned ? result._vint16 : static_cast<fcml_uint16_t>( result._vint16 );
                thisValue = (*signedExpressionFn)( thisValue, thatValue );
                result._vint16 = static_cast<fcml_int16_t>( thisValue );
                break;
            case FCML_DS_32:
                thisValue = result._isSigned ? result._vint32 : static_cast<fcml_uint32_t>( result._vint32 );
                thisValue = (*signedExpressionFn)( thisValue, thatValue );
                result._vint32 = static_cast<fcml_int32_t>( thisValue );
                break;
            case FCML_DS_64:
                thisValue = result._isSigned ? result._vint64 : static_cast<fcml_uint64_t>( result._vint64 );
                thisValue = (*signedExpressionFn)( thisValue, thatValue );
                result._vint64 = thisValue;
                break;
            }

        } else {

            fcml_uint64_t thisValue;
            fcml_uint64_t thatValue;

            // Prepare "that". It has to be converted to the same sign.
            switch( src._size ) {
            case FCML_DS_8:
                thatValue = src._isSigned ? src._vint8 : static_cast<fcml_uint8_t>( src._vint8 );
                break;
            case FCML_DS_16:
                thatValue = src._isSigned ? src._vint16 : static_cast<fcml_uint16_t>( src._vint16 );
                break;
            case FCML_DS_32:
                thatValue = src._isSigned ? src._vint32 : static_cast<fcml_uint32_t>( src._vint32 );
                break;
            case FCML_DS_64:
                thatValue = src._isSigned ? src._vint64 : static_cast<fcml_uint64_t>( src._vint64 );
                break;
            }

            // Now "this".
            switch( result._size ) {
            case FCML_DS_8:
                thisValue = result._isSigned ? result._vint8 : static_cast<fcml_uint8_t>( result._vint8 );
                thisValue = (*unsignedExpressionFn)( thisValue, thatValue );
                result._vint8 = static_cast<fcml_int8_t>( thisValue );
                break;
            case FCML_DS_16:
                thisValue = result._isSigned ? result._vint16 : static_cast<fcml_uint16_t>( result._vint16 );
                thisValue = (*unsignedExpressionFn)( thisValue, thatValue );
                result._vint16 = static_cast<fcml_int16_t>( thisValue );
                break;
            case FCML_DS_32:
                thisValue = result._isSigned ? result._vint32 : static_cast<fcml_uint32_t>( result._vint32 );
                thisValue = (*unsignedExpressionFn)( thisValue, thatValue );
                result._vint32 = static_cast<fcml_int32_t>( thisValue );
                break;
            case FCML_DS_64:
                thisValue = result._isSigned ? result._vint64 : static_cast<fcml_uint64_t>( result._vint64 );
                thisValue = (*unsignedExpressionFn)( thisValue, thatValue );
                result._vint64 = thisValue;
                break;
            }
        }

    }

private:
    fcml_usize _size;
    fcml_bool _isSigned;
    fcml_int8_t _vint8;
    fcml_int16_t _vint16;
    fcml_int32_t _vint32;
    fcml_int64_t _vint64;
};

class Register {
public:

    // TODO: Do we need this REG_ prefix here?
    enum RegisterType {
        REG_UNDEFINED = FCML_REG_UNDEFINED,
        REG_GPR = FCML_REG_GPR,
        REG_SIMD = FCML_REG_SIMD,
        REG_FPU = FCML_REG_FPU,
        REG_SEG = FCML_REG_SEG,
        REG_CR = FCML_REG_CR,
        REG_DR = FCML_REG_DR,
        REG_IP = FCML_REG_IP,
        REG_OPMASK = FCML_REG_OPMASK
    };

    Register() :
        _type(REG_UNDEFINED),
        _size(0),
        _reg(0),
        _x64_exp(FCML_FALSE) {
    }

    Register( const fcml_st_register &reg ) :
        _type(static_cast<RegisterType>( reg.type )),
        _size(reg.size),
        _reg(reg.reg),
        _x64_exp(reg.x64_exp? true : false) {
    }

    Register( fcml_uint8_t reg, fcml_usize size, RegisterType type = REG_GPR, fcml_bool x64_exp = FCML_FALSE ) :
        _type(type),
        _size(size),
        _reg(reg),
        _x64_exp(x64_exp?true:false) {
    }

    virtual ~Register() {
    }

public:

    fcml_uint8_t getReg() const {
        return _reg;
    }

    void setReg( fcml_uint8_t reg ) {
        _reg = reg;
    }

    fcml_usize getSize() const {
        return _size;
    }

    void setSize( fcml_usize size ) {
        _size = size;
    }

    RegisterType getType() const {
        return _type;
    }

    void setType( RegisterType type ) {
        _type = type;
    }

    bool getX64Exp() const {
        return _x64_exp;
    }

    void setX64Exp( bool x64Exp ) {
        _x64_exp = x64Exp;
    }

public:

    bool operator==( const Register &reg ) const {
        return _reg == reg._reg && _type == reg._type && _size == reg._size && _x64_exp == reg._x64_exp;
    }

    bool operator!=( const Register &reg ) const {
        return !( reg == *this );
    }

public:

    static const Register UNDEF() {
        Register reg( 0, 0, Register::REG_UNDEFINED, FCML_FALSE );
        return reg;
    }

    static const Register AL() {
        Register reg( ::fcml_reg_AL );
        return reg;
    }

    static const Register AX() {
        Register reg( ::fcml_reg_AX );
        return reg;
    }

    static const Register EAX() {
        Register reg( ::fcml_reg_EAX );
        return reg;
    }

    static const Register RAX() {
        Register reg( ::fcml_reg_RAX );
        return reg;
    }

    static const Register MM0() {
        Register reg( ::fcml_reg_MM0 );
        return reg;
    }

    static const Register XMM0() {
        Register reg( ::fcml_reg_XMM0 );
        return reg;
    }

    static const Register YMM0() {
        Register reg( ::fcml_reg_YMM0 );
        return reg;
    }

    static const Register ZMM0() {
        Register reg( ::fcml_reg_ZMM0 );
        return reg;
    }

    static const Register CL() {
        Register reg( ::fcml_reg_CL );
        return reg;
    }

    static const Register CX() {
        Register reg( ::fcml_reg_CX );
        return reg;
    }

    static const Register ECX() {
        Register reg( ::fcml_reg_ECX );
        return reg;
    }

    static const Register RCX() {
        Register reg( ::fcml_reg_RCX );
        return reg;
    }

    static const Register MM1() {
        Register reg( ::fcml_reg_MM1 );
        return reg;
    }

    static const Register XMM1() {
        Register reg( ::fcml_reg_XMM1 );
        return reg;
    }

    static const Register YMM1() {
        Register reg( ::fcml_reg_YMM1 );
        return reg;
    }

    static const Register ZMM1() {
        Register reg( ::fcml_reg_ZMM1 );
        return reg;
    }

    static const Register DL() {
        Register reg( ::fcml_reg_DL );
        return reg;
    }

    static const Register DX() {
        Register reg( ::fcml_reg_DX );
        return reg;
    }

    static const Register EDX() {
        Register reg( ::fcml_reg_EDX );
        return reg;
    }

    static const Register RDX() {
        Register reg( ::fcml_reg_RDX );
        return reg;
    }

    static const Register MM2() {
        Register reg( ::fcml_reg_MM2 );
        return reg;
    }

    static const Register XMM2() {
        Register reg( ::fcml_reg_XMM2 );
        return reg;
    }

    static const Register YMM2() {
        Register reg( ::fcml_reg_YMM2 );
        return reg;
    }

    static const Register ZMM2() {
        Register reg( ::fcml_reg_ZMM2 );
        return reg;
    }

    static const Register BL() {
        Register reg( ::fcml_reg_BL );
        return reg;
    }

    static const Register BX() {
        Register reg( ::fcml_reg_BX );
        return reg;
    }

    static const Register EBX() {
        Register reg( ::fcml_reg_EBX );
        return reg;
    }

    static const Register RBX() {
        Register reg( ::fcml_reg_RBX );
        return reg;
    }

    static const Register MM3() {
        Register reg( ::fcml_reg_MM3 );
        return reg;
    }

    static const Register XMM3() {
        Register reg( ::fcml_reg_XMM3 );
        return reg;
    }

    static const Register YMM3() {
        Register reg( ::fcml_reg_YMM3 );
        return reg;
    }

    static const Register ZMM3() {
        Register reg( ::fcml_reg_ZMM3 );
        return reg;
    }

    static const Register AH() {
        Register reg( ::fcml_reg_AH );
        return reg;
    }

    static const Register SPL() {
        Register reg( ::fcml_reg_SPL );
        return reg;
    }

    static const Register SP() {
        Register reg( ::fcml_reg_SP );
        return reg;
    }

    static const Register ESP() {
        Register reg( ::fcml_reg_ESP );
        return reg;
    }

    static const Register RSP() {
        Register reg( ::fcml_reg_RSP );
        return reg;
    }

    static const Register MM4() {
        Register reg( ::fcml_reg_MM4 );
        return reg;
    }

    static const Register XMM4() {
        Register reg( ::fcml_reg_XMM4 );
        return reg;
    }

    static const Register YMM4() {
        Register reg( ::fcml_reg_YMM4 );
        return reg;
    }

    static const Register ZMM4() {
        Register reg( ::fcml_reg_ZMM4 );
        return reg;
    }


    static const Register CH() {
        Register reg( ::fcml_reg_CH );
        return reg;
    }

    static const Register BPL() {
        Register reg( ::fcml_reg_BPL );
        return reg;
    }

    static const Register BP() {
        Register reg( ::fcml_reg_BP );
        return reg;
    }

    static const Register EBP() {
        Register reg( ::fcml_reg_EBP );
        return reg;
    }

    static const Register RBP() {
        Register reg( ::fcml_reg_RBP );
        return reg;
    }

    static const Register MM5() {
        Register reg( ::fcml_reg_MM5 );
        return reg;
    }

    static const Register XMM5() {
        Register reg( ::fcml_reg_XMM5 );
        return reg;
    }

    static const Register YMM5() {
        Register reg( ::fcml_reg_YMM5 );
        return reg;
    }

    static const Register ZMM5() {
        Register reg( ::fcml_reg_ZMM5 );
        return reg;
    }

    static const Register DH() {
        Register reg( ::fcml_reg_DH );
        return reg;
    }

    static const Register SIL() {
        Register reg( ::fcml_reg_SIL );
        return reg;
    }

    static const Register SI() {
        Register reg( ::fcml_reg_SI );
        return reg;
    }

    static const Register ESI() {
        Register reg( ::fcml_reg_ESI );
        return reg;
    }

    static const Register RSI() {
        Register reg( ::fcml_reg_RSI );
        return reg;
    }

    static const Register MM6() {
        Register reg( ::fcml_reg_MM6 );
        return reg;
    }

    static const Register XMM6() {
        Register reg( ::fcml_reg_XMM6 );
        return reg;
    }

    static const Register YMM6() {
        Register reg( ::fcml_reg_YMM6 );
        return reg;
    }

    static const Register ZMM6() {
        Register reg( ::fcml_reg_ZMM6 );
        return reg;
    }


    static const Register BH() {
        Register reg( ::fcml_reg_BH );
        return reg;
    }

    static const Register DIL() {
        Register reg( ::fcml_reg_DIL );
        return reg;
    }

    static const Register DI() {
        Register reg( ::fcml_reg_DI );
        return reg;
    }

    static const Register EDI() {
        Register reg( ::fcml_reg_EDI );
        return reg;
    }

    static const Register RDI() {
        Register reg( ::fcml_reg_RDI );
        return reg;
    }

    static const Register MM7() {
        Register reg( ::fcml_reg_MM7 );
        return reg;
    }

    static const Register XMM7() {
        Register reg( ::fcml_reg_XMM7 );
        return reg;
    }

    static const Register YMM7() {
        Register reg( ::fcml_reg_YMM7 );
        return reg;
    }

    static const Register ZMM7() {
        Register reg( ::fcml_reg_ZMM7 );
        return reg;
    }

    static const Register R8L() {
        Register reg( ::fcml_reg_R8L );
        return reg;
    }

    static const Register R8W() {
        Register reg( ::fcml_reg_R8W );
        return reg;
    }

    static const Register R8D() {
        Register reg( ::fcml_reg_R8D );
        return reg;
    }

    static const Register R8() {
        Register reg( ::fcml_reg_R8 );
        return reg;
    }

    static const Register XMM8() {
        Register reg( ::fcml_reg_XMM8 );
        return reg;
    }

    static const Register YMM8() {
        Register reg( ::fcml_reg_YMM8 );
        return reg;
    }

    static const Register ZMM8() {
        Register reg( ::fcml_reg_ZMM8 );
        return reg;
    }

    static const Register R9L() {
        Register reg( ::fcml_reg_R9L );
        return reg;
    }

    static const Register R9W() {
        Register reg( ::fcml_reg_R9W );
        return reg;
    }

    static const Register R9D() {
        Register reg( ::fcml_reg_R9D );
        return reg;
    }

    static const Register R9() {
        Register reg( ::fcml_reg_R9 );
        return reg;
    }

    static const Register XMM9() {
        Register reg( ::fcml_reg_XMM9 );
        return reg;
    }

    static const Register YMM9() {
        Register reg( ::fcml_reg_YMM9 );
        return reg;
    }

    static const Register ZMM9() {
        Register reg( ::fcml_reg_ZMM9 );
        return reg;
    }

    static const Register R10L() {
        Register reg( ::fcml_reg_R10L );
        return reg;
    }

    static const Register R10W() {
        Register reg( ::fcml_reg_R10W );
        return reg;
    }

    static const Register R10D() {
        Register reg( ::fcml_reg_R10D );
        return reg;
    }

    static const Register R10() {
        Register reg( ::fcml_reg_R10 );
        return reg;
    }

    static const Register XMM10() {
        Register reg( ::fcml_reg_XMM10 );
        return reg;
    }

    static const Register YMM10() {
        Register reg( ::fcml_reg_YMM10 );
        return reg;
    }

    static const Register ZMM10() {
        Register reg( ::fcml_reg_ZMM10 );
        return reg;
    }

    static const Register R11L() {
        Register reg( ::fcml_reg_R11L );
        return reg;
    }

    static const Register R11W() {
        Register reg( ::fcml_reg_R11W );
        return reg;
    }

    static const Register R11D() {
        Register reg( ::fcml_reg_R11D );
        return reg;
    }

    static const Register R11() {
        Register reg( ::fcml_reg_R11 );
        return reg;
    }

    static const Register XMM11() {
        Register reg( ::fcml_reg_XMM11 );
        return reg;
    }

    static const Register YMM11() {
        Register reg( ::fcml_reg_YMM11 );
        return reg;
    }

    static const Register ZMM11() {
        Register reg( ::fcml_reg_ZMM11 );
        return reg;
    }

    static const Register R12L() {
        Register reg( ::fcml_reg_R12L );
        return reg;
    }

    static const Register R12W() {
        Register reg( ::fcml_reg_R12W );
        return reg;
    }

    static const Register R12D() {
        Register reg( ::fcml_reg_R12D );
        return reg;
    }

    static const Register R12() {
        Register reg( ::fcml_reg_R12 );
        return reg;
    }

    static const Register XMM12() {
        Register reg( ::fcml_reg_XMM12 );
        return reg;
    }

    static const Register YMM12() {
        Register reg( ::fcml_reg_YMM12 );
        return reg;
    }

    static const Register ZMM12() {
        Register reg( ::fcml_reg_ZMM12 );
        return reg;
    }

    static const Register R13L() {
        Register reg( ::fcml_reg_R13L );
        return reg;
    }

    static const Register R13W() {
        Register reg( ::fcml_reg_R13W );
        return reg;
    }

    static const Register R13D() {
        Register reg( ::fcml_reg_R13D );
        return reg;
    }

    static const Register R13() {
        Register reg( ::fcml_reg_R13 );
        return reg;
    }

    static const Register XMM13() {
        Register reg( ::fcml_reg_XMM13 );
        return reg;
    }

    static const Register YMM13() {
        Register reg( ::fcml_reg_YMM13 );
        return reg;
    }

    static const Register ZMM13() {
        Register reg( ::fcml_reg_ZMM13 );
        return reg;
    }

    static const Register R14L() {
        Register reg( ::fcml_reg_R14L );
        return reg;
    }

    static const Register R14W() {
        Register reg( ::fcml_reg_R14W );
        return reg;
    }

    static const Register R14D() {
        Register reg( ::fcml_reg_R14D );
        return reg;
    }

    static const Register R14() {
        Register reg( ::fcml_reg_R14 );
        return reg;
    }

    static const Register XMM14() {
        Register reg( ::fcml_reg_XMM14 );
        return reg;
    }

    static const Register YMM14() {
        Register reg( ::fcml_reg_YMM14 );
        return reg;
    }

    static const Register ZMM14() {
        Register reg( ::fcml_reg_ZMM14 );
        return reg;
    }

    static const Register R15L() {
        Register reg( ::fcml_reg_R15L );
        return reg;
    }

    static const Register R15W() {
        Register reg( ::fcml_reg_R15W );
        return reg;
    }

    static const Register R15D() {
        Register reg( ::fcml_reg_R15D );
        return reg;
    }

    static const Register R15() {
        Register reg( ::fcml_reg_R15 );
        return reg;
    }

    static const Register XMM15() {
        Register reg( ::fcml_reg_XMM15 );
        return reg;
    }

    static const Register YMM15() {
        Register reg( ::fcml_reg_YMM15 );
        return reg;
    }

    static const Register ZMM15() {
        Register reg( ::fcml_reg_ZMM15 );
        return reg;
    }

    static const Register XMM16() {
        Register reg( ::fcml_reg_XMM16 );
        return reg;
    }

    static const Register YMM16() {
        Register reg( ::fcml_reg_YMM16 );
        return reg;
    }

    static const Register ZMM16() {
        Register reg( ::fcml_reg_ZMM16 );
        return reg;
    }

    static const Register XMM17() {
        Register reg( ::fcml_reg_XMM17 );
        return reg;
    }

    static const Register YMM17() {
        Register reg( ::fcml_reg_YMM17 );
        return reg;
    }

    static const Register ZMM17() {
        Register reg( ::fcml_reg_ZMM17 );
        return reg;
    }

    static const Register XMM18() {
        Register reg( ::fcml_reg_XMM18 );
        return reg;
    }

    static const Register YMM18() {
        Register reg( ::fcml_reg_YMM18 );
        return reg;
    }

    static const Register ZMM18() {
        Register reg( ::fcml_reg_ZMM18 );
        return reg;
    }

    static const Register XMM19() {
        Register reg( ::fcml_reg_XMM19 );
        return reg;
    }

    static const Register YMM19() {
        Register reg( ::fcml_reg_YMM19 );
        return reg;
    }

    static const Register ZMM19() {
        Register reg( ::fcml_reg_ZMM19 );
        return reg;
    }

    static const Register XMM20() {
        Register reg( ::fcml_reg_XMM20 );
        return reg;
    }

    static const Register YMM20() {
        Register reg( ::fcml_reg_YMM20 );
        return reg;
    }

    static const Register ZMM20() {
        Register reg( ::fcml_reg_ZMM20 );
        return reg;
    }

    static const Register XMM21() {
        Register reg( ::fcml_reg_XMM21 );
        return reg;
    }

    static const Register YMM21() {
        Register reg( ::fcml_reg_YMM21 );
        return reg;
    }

    static const Register ZMM21() {
        Register reg( ::fcml_reg_ZMM21 );
        return reg;
    }

    static const Register XMM22() {
        Register reg( ::fcml_reg_XMM22 );
        return reg;
    }

    static const Register YMM22() {
        Register reg( ::fcml_reg_YMM22 );
        return reg;
    }

    static const Register ZMM22() {
        Register reg( ::fcml_reg_ZMM22 );
        return reg;
    }

    static const Register XMM23() {
        Register reg( ::fcml_reg_XMM23 );
        return reg;
    }

    static const Register YMM23() {
        Register reg( ::fcml_reg_YMM23 );
        return reg;
    }

    static const Register ZMM23() {
        Register reg( ::fcml_reg_ZMM23 );
        return reg;
    }

    static const Register XMM24() {
        Register reg( ::fcml_reg_XMM24 );
        return reg;
    }

    static const Register YMM24() {
        Register reg( ::fcml_reg_YMM24 );
        return reg;
    }

    static const Register ZMM24() {
        Register reg( ::fcml_reg_ZMM24 );
        return reg;
    }

    static const Register XMM25() {
        Register reg( ::fcml_reg_XMM25 );
        return reg;
    }

    static const Register YMM25() {
        Register reg( ::fcml_reg_YMM25 );
        return reg;
    }

    static const Register ZMM25() {
        Register reg( ::fcml_reg_ZMM25 );
        return reg;
    }

    static const Register XMM26() {
        Register reg( ::fcml_reg_XMM26 );
        return reg;
    }

    static const Register YMM26() {
        Register reg( ::fcml_reg_YMM26 );
        return reg;
    }

    static const Register ZMM26() {
        Register reg( ::fcml_reg_ZMM26 );
        return reg;
    }

    static const Register XMM27() {
        Register reg( ::fcml_reg_XMM27 );
        return reg;
    }

    static const Register YMM27() {
        Register reg( ::fcml_reg_YMM27 );
        return reg;
    }

    static const Register ZMM27() {
        Register reg( ::fcml_reg_ZMM27 );
        return reg;
    }

    static const Register XMM28() {
        Register reg( ::fcml_reg_XMM28 );
        return reg;
    }

    static const Register YMM28() {
        Register reg( ::fcml_reg_YMM28 );
        return reg;
    }

    static const Register ZMM28() {
        Register reg( ::fcml_reg_ZMM28 );
        return reg;
    }

    static const Register XMM29() {
        Register reg( ::fcml_reg_XMM29 );
        return reg;
    }

    static const Register YMM29() {
        Register reg( ::fcml_reg_YMM29 );
        return reg;
    }

    static const Register ZMM29() {
        Register reg( ::fcml_reg_ZMM29 );
        return reg;
    }

    static const Register XMM30() {
        Register reg( ::fcml_reg_XMM30 );
        return reg;
    }

    static const Register YMM30() {
        Register reg( ::fcml_reg_YMM30 );
        return reg;
    }

    static const Register ZMM30() {
        Register reg( ::fcml_reg_ZMM30 );
        return reg;
    }

    static const Register XMM31() {
        Register reg( ::fcml_reg_XMM31 );
        return reg;
    }

    static const Register YMM31() {
        Register reg( ::fcml_reg_YMM31 );
        return reg;
    }

    static const Register ZMM31() {
        Register reg( ::fcml_reg_ZMM31 );
        return reg;
    }

    static const Register ES() {
        Register reg( ::fcml_reg_ES );
        return reg;
    }

    static const Register CS() {
        Register reg( ::fcml_reg_CS );
        return reg;
    }

    static const Register SS() {
        Register reg( ::fcml_reg_SS );
        return reg;
    }

    static const Register DS() {
        Register reg( ::fcml_reg_DS );
        return reg;
    }

    static const Register FS() {
        Register reg( ::fcml_reg_FS );
        return reg;
    }

    static const Register GS() {
        Register reg( ::fcml_reg_GS );
        return reg;
    }

    static const Register ST0() {
        Register reg( ::fcml_reg_ST0 );
        return reg;
    }

    static const Register ST1() {
        Register reg( ::fcml_reg_ST1 );
        return reg;
    }

    static const Register ST2() {
        Register reg( ::fcml_reg_ST2 );
        return reg;
    }

    static const Register ST3() {
        Register reg( ::fcml_reg_ST3 );
        return reg;
    }

    static const Register ST4() {
        Register reg( ::fcml_reg_ST4 );
        return reg;
    }

    static const Register ST5() {
        Register reg( ::fcml_reg_ST5 );
        return reg;
    }

    static const Register ST6() {
        Register reg( ::fcml_reg_ST6 );
        return reg;
    }

    static const Register ST7() {
        Register reg( ::fcml_reg_ST7 );
        return reg;
    }

    static const Register CR0() {
        Register reg( ::fcml_reg_CR0 );
        return reg;
    }

    static const Register CR2() {
        Register reg( ::fcml_reg_CR2 );
        return reg;
    }

    static const Register CR3() {
        Register reg( ::fcml_reg_CR3 );
        return reg;
    }

    static const Register CR4() {
        Register reg( ::fcml_reg_CR4 );
        return reg;
    }

    static const Register CR8() {
        Register reg( ::fcml_reg_CR8 );
        return reg;
    }

    static const Register DR0() {
        Register reg( ::fcml_reg_DR0 );
        return reg;
    }

    static const Register DR1() {
        Register reg( ::fcml_reg_DR1 );
        return reg;
    }

    static const Register DR2() {
        Register reg( ::fcml_reg_DR2 );
        return reg;
    }

    static const Register DR3() {
        Register reg( ::fcml_reg_DR3 );
        return reg;
    }

    static const Register DR4() {
        Register reg( ::fcml_reg_DR4 );
        return reg;
    }

    static const Register DR5() {
        Register reg( ::fcml_reg_DR5 );
        return reg;
    }

    static const Register DR6() {
        Register reg( ::fcml_reg_DR6 );
        return reg;
    }

    static const Register DR7() {
        Register reg( ::fcml_reg_DR7 );
        return reg;
    }

    static const Register IP() {
        Register reg( ::fcml_reg_IP );
        return reg;
    }

    static const Register EIP() {
        Register reg( ::fcml_reg_EIP );
        return reg;
    }

    static const Register RIP() {
        Register reg( ::fcml_reg_RIP );
        return reg;
    }

    static const Register K0() {
        Register reg( ::fcml_reg_K0 );
        return reg;
    }

    static const Register K1() {
        Register reg( ::fcml_reg_K1 );
        return reg;
    }

    static const Register K2() {
        Register reg( ::fcml_reg_K2 );
        return reg;
    }

    static const Register K3() {
        Register reg( ::fcml_reg_K3 );
        return reg;
    }

    static const Register K4() {
        Register reg( ::fcml_reg_K4 );
        return reg;
    }

    static const Register K5() {
        Register reg( ::fcml_reg_K5 );
        return reg;
    }

    static const Register K6() {
        Register reg( ::fcml_reg_K6 );
        return reg;
    }

    static const Register K7() {
        Register reg( ::fcml_reg_K7 );
        return reg;
    }

private:

    RegisterType _type;
    fcml_usize _size;
    fcml_uint8_t _reg;
    bool _x64_exp;

};

class FarPointer {

public:

    FarPointer() :
        _segment(0),
        _offset_size(0),
        _offset16(0),
        _offset32(0) {
    }

    FarPointer( fcml_uint16_t segment, fcml_int16_t offset16 ) :
        _segment(segment),
        _offset_size(FCML_DS_16),
        _offset16(offset16),
        _offset32(0) {
    }
    FarPointer( fcml_uint16_t segment, fcml_int32_t offset32 ) :
        _segment(segment),
        _offset_size(FCML_DS_32),
        _offset16(0),
        _offset32(offset32) {
    }

    virtual ~FarPointer() {
    }

public:

    bool operator==( const FarPointer &fp ) const {
        fcml_int32_t thisOffset;
        switch( _offset_size ) {
        case FCML_DS_32:
            thisOffset = _offset32;
            break;
        case FCML_DS_16:
            thisOffset = _offset16;
            break;
        }
        fcml_int32_t thatOffset;
        switch( fp._offset_size ) {
        case FCML_DS_32:
            thatOffset = fp._offset32;
            break;
        case FCML_DS_16:
            thatOffset = fp._offset16;
            break;
        }
        return thisOffset == thatOffset;
    }

    bool operator!=( const FarPointer &fp) const {
        return !(fp == *this);
    }

public:

    static FarPointer off16( fcml_uint16_t segment, fcml_int16_t offset ) {
        return FarPointer(segment, offset);
    }

    static FarPointer off32( fcml_uint16_t segment, fcml_int32_t offset ) {
        return FarPointer(segment, offset);
    }

public:

    fcml_usize getOffsetSize() const {
        return _offset_size;
    }

    void setOffsetSize( fcml_usize offsetSize ) {
        _offset_size = offsetSize;
    }

    fcml_int16_t getOffset16() const {
        return _offset16;
    }

    void setOffset16( fcml_int16_t offset16 ) {
        _offset16 = offset16;
    }

    fcml_int32_t getOffset32() const {
        return _offset32;
    }

    void setOffset32( fcml_int32_t offset32 ) {
        _offset32 = offset32;
    }

    fcml_uint16_t getSegment() const {
        return _segment;
    }

    void setSegment( fcml_uint16_t segment ) {
        _segment = segment;
    }

private:

    fcml_uint16_t _segment;
    fcml_usize _offset_size;
    fcml_int16_t _offset16;
    fcml_int32_t _offset32;

};

class SegmentSelector {
public:

    SegmentSelector() :
        _segmentSelector(),
        _isDefaultReg(false) {
    }

    SegmentSelector( const Register &segmentSelector, bool isDefaultReg = FCML_TRUE ) :
        _segmentSelector(segmentSelector),
        _isDefaultReg(isDefaultReg) {
    }

    virtual ~SegmentSelector() {
    }

public:

    bool operator==( const SegmentSelector &segmentSelector ) const {
        // It really doesn't matter if it is the default segment register in a given context.
        return segmentSelector._segmentSelector == _segmentSelector;
    }

    bool operator!=( const SegmentSelector &segmentSelector ) const {
        return !(*this == segmentSelector);
    }

    operator Register() const {
        return _segmentSelector;
    }

    SegmentSelector& operator=( const SegmentSelector &reg ) {
        if( &reg != this ) {
            _isDefaultReg = reg._isDefaultReg;
            _segmentSelector = reg._segmentSelector;
        }
        return *this;
    }

public:

    static SegmentSelector seg( const Register &segmentSelector, bool isDefaultReg ) {
        return SegmentSelector( segmentSelector, isDefaultReg );
    }

public:

    bool isDefaultReg() const {
        return _isDefaultReg;
    }

    void setDefaultReg( bool isDefaultReg ) {
        _isDefaultReg = isDefaultReg;
    }

    const Register& getSegmentSelector() const {
        return _segmentSelector;
    }

    Register& getSegmentSelector() {
        return _segmentSelector;
    }

    void setSegmentSelector( const Register& segmentSelector ) {
        _segmentSelector = segmentSelector;
    }

private:
    Register _segmentSelector;
    bool _isDefaultReg;
};

class EffectiveAddress {
public:

    EffectiveAddress() :
        _scaleFactor(0){
    }

    EffectiveAddress( const Integer &displacement ) :
        _scaleFactor(0),
        _displacement(displacement) {
    }

    EffectiveAddress( const Register &base ) :
        _base(base),
        _scaleFactor(0) {
    }

    EffectiveAddress( const Register &base, const Integer &displacement ) :
        _base(base),
        _scaleFactor(0),
        _displacement(displacement) {
    }

    EffectiveAddress( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) :
        _index(index),
        _scaleFactor(scaleFactor),
        _displacement(displacement) {
    }

    EffectiveAddress( const Register &base, const Register &index ) :
        _base(base),
        _index(index),
        _scaleFactor(0) {
    }

    EffectiveAddress( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) :
        _base(base),
        _index(index),
        _scaleFactor(scaleFactor) {
    }

    EffectiveAddress( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) :
        _base(base),
        _index(index),
        _scaleFactor(scaleFactor),
        _displacement(displacement) {
    }

    virtual ~EffectiveAddress() {
    }

public:

    bool operator==( const EffectiveAddress &address ) const {
        if( &address == this ) {
            return true;
        }
        return _base == address._base &&
                _index == address._index &&
                _scaleFactor == address._scaleFactor &&
                _displacement == address._displacement;
    }

    bool operator!=( const EffectiveAddress &address ) const {
        return !(address == *this);
    }

public:

    static EffectiveAddress addr( const Integer &displacement ) {
        return EffectiveAddress( displacement );
    }

    static EffectiveAddress addr( const Register &base ) {
        return EffectiveAddress( base );
    }

    static EffectiveAddress addr( const Register &base, const Integer &displacement ) {
        return EffectiveAddress( base, displacement );
    }

    static EffectiveAddress addr( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return EffectiveAddress( index, scaleFactor, displacement );
    }

    static EffectiveAddress addr( const Register &base, const Register &index ) {
        return EffectiveAddress( base, index, 0 );
    }

    static EffectiveAddress addr( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        return EffectiveAddress( base, index, scaleFactor );
    }

    static EffectiveAddress addr( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return EffectiveAddress( base, index, scaleFactor, displacement );
    }

public:

    const Register& getBase() const {
        return _base;
    }

    Register& getBase() {
        return _base;
    }

    EffectiveAddress& setBase( const Register &base ) {
        _base = base;
        return *this;
    }

    const Integer& getDisplacement() const {
        return _displacement;
    }

    Integer& getDisplacement() {
        return _displacement;
    }

    EffectiveAddress& setDisplacement( const Integer &displacement ) {
        _displacement = displacement;
        return *this;
    }

    const Register& getIndex() const {
        return _index;
    }

    Register& getIndex() {
        return _index;
    }

    EffectiveAddress& setIndex( const Register &index ) {
        _index = index;
        return *this;
    }

    fcml_uint8_t getScaleFactor() const {
        return _scaleFactor;
    }

    EffectiveAddress& setScaleFactor( fcml_uint8_t scaleFactor ) {
        _scaleFactor = scaleFactor;
        return *this;
    }

private:
    Register _base;
    Register _index;
    fcml_uint8_t _scaleFactor;
    Integer _displacement;
};

class Address {

public:

    enum AddressForm {
        AF_UNDEFINED = FCML_AF_UNDEFINED,
        AF_OFFSET = FCML_AF_OFFSET,
        AF_COMBINED = FCML_AF_COMBINED
    };

    Address() :
        _size_operator( FCML_DS_UNDEF ),
        _address_form( AF_UNDEFINED ) {
    }

    Address( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) :
        _size_operator( sizeOperator ),
        _address_form( AF_OFFSET ),
        _offset( offset ) {
    }

    Address( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) :
        _size_operator( sizeOperator ),
        _address_form( AF_COMBINED ),
        _effective_address( effectiveAddress ) {
    }

    Address( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) :
        _size_operator( sizeOperator ),
        _address_form( AF_COMBINED ),
        _segment_selector( segmentSelector ),
        _effective_address( effectiveAddress ) {
    }

    virtual ~Address() {
    }

public:

    static Address effective( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return effective( EffectiveAddress( displacement ), sizeOperator );
    }

    static Address effective( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return effective( EffectiveAddress( base ), sizeOperator );
    }

    static Address effective( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return effective( EffectiveAddress( base, displacement ), sizeOperator );
    }

    static Address effective( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return effective( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator );
    }

    static Address effective( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return effective( EffectiveAddress( base, index, 0 ), sizeOperator );
    }

    static Address effective( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return effective( EffectiveAddress( base, index, scaleFactor ), sizeOperator );
    }

    static Address effective( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return effective( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator );
    }


public:

    bool operator==( const Address &address ) const {
        if( &address == this ) {
            return true;
        }
        return _size_operator == address._size_operator &&
                _address_form == address._address_form &&
                _segment_selector == address._segment_selector &&
                _effective_address == address._effective_address &&
                _offset == address._offset;
    }

    bool operator!=( const Address &address ) const {
        return !(address == *this );
    }

public:

    static Address effective( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return Address( effectiveAddress, segmentSelector, sizeOperator );
    }

    static Address effective( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return Address( effectiveAddress, sizeOperator );
    }

    static Address offset( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return Address( offset, sizeOperator );
    }

public:

    bool isEffectiveAddress() const {
        return _address_form == AF_COMBINED;
    }

    bool isOffset() const {
        return _address_form == AF_OFFSET;
    }

    AddressForm getAddressForm() const {
        return _address_form;
    }

    Address& setAddressForm( AddressForm addressForm ) {
        _address_form = addressForm;
        return *this;
    }

    const EffectiveAddress& getEffectiveAddress() const {
        return _effective_address;
    }

    EffectiveAddress& getEffectiveAddress() {
        return _effective_address;
    }

    Address& setEffectiveAddress( const EffectiveAddress& effectiveAddress ) {
        _effective_address = effectiveAddress;
        return *this;
    }

    const Integer& getOffset() const {
        return _offset;
    }

    Integer& getOffset() {
        return _offset;
    }

    Address& setOffset( const Integer &offset ) {
        this->_offset = offset;
        return *this;
    }

    const SegmentSelector& getSegmentSelector() const {
        return _segment_selector;
    }

    SegmentSelector& getSegmentSelector() {
        return _segment_selector;
    }

    Address& setSegmentSelector( const SegmentSelector &segmentSelector ) {
        _segment_selector = segmentSelector;
        return *this;
    }

    fcml_usize getSizeOperator() const {
        return _size_operator;
    }

    Address& setSizeOperator( fcml_usize sizeOperator ) {
        _size_operator = sizeOperator;
        return *this;
    }

private:

    fcml_usize _size_operator;
    AddressForm _address_form;
    SegmentSelector _segment_selector;
    EffectiveAddress _effective_address;
    Integer _offset;

};

class Decorators {
public:

    enum EmbeededRoundingControl {
        FCML_ERC_RNE = 0,
        FCML_ERC_RD,
        FCML_ERC_RU,
        FCML_ERC_RZ
    };

    Decorators() : _z(FCML_FALSE), _operandMaskReg(Register::UNDEF()),
        _sae(FCML_FALSE) {
    }

    Decorators& setZ(fcml_bool z) {
        _z = z;
        return *this;
    }

    Decorators& setBcast(const Nullable<fcml_uint8_t> &bcast) {
        _bcast = bcast;
        return *this;
    }

    Decorators& setOpmaskReg( const Register& opmaskReg ) {
        _operandMaskReg = opmaskReg;
        return *this;
    }

    Decorators& setEr(const Nullable<EmbeededRoundingControl> &er) {
        _er = er;
        return *this;
    }

    Decorators& setSae(const fcml_bool sae) {
        _sae = sae;
        return *this;
    }

    fcml_bool isZ() const {
        return _z;
    }

    const Nullable<fcml_uint8_t>& getBcast() const {
        return _bcast;
    }

    const Register& getOpmaskReg() const {
        return _operandMaskReg;
    }

    Register& getOpmaskReg() {
        return _operandMaskReg;
    }

    const Nullable<EmbeededRoundingControl>& getEr() const {
        return _er;
    }

    fcml_bool isSae() const {
        return _sae;
    }

public:

    bool operator==(const Decorators &decorators) const {
        if(&decorators == this) {
            return true;
        }
        return _z == decorators._z &&
                _bcast == decorators._bcast &&
                _operandMaskReg == decorators._operandMaskReg &&
                _er == decorators._er &&
                _sae == decorators._sae;
    }

    bool operator!=(const Decorators &decorators) const {
        return !(decorators == *this);
    }

private:
    Nullable<fcml_uint8_t> _bcast;
    fcml_bool _z;
    Register _operandMaskReg;
    Nullable<EmbeededRoundingControl> _er;
    fcml_bool _sae;
};

class Operand {
public:

    enum OperandType {
        OT_NONE = FCML_OT_NONE,
        OT_IMMEDIATE = FCML_OT_IMMEDIATE,
        OT_FAR_POINTER = FCML_OT_FAR_POINTER,
        OT_ADDRESS = FCML_OT_ADDRESS,
        OT_REGISTER = FCML_OT_REGISTER,
        OT_VIRTUAL = FCML_OT_VIRTUAL
    };

    Operand() :
        _hints( FCML_OP_HINT_UNDEFIEND ),
        _operandType( OT_NONE ) {
    }

    Operand( const Integer &imm, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) :
        _hints( hints ),
        _operandType(OT_IMMEDIATE ),
        _immediate( imm ) {
    }

    Operand( const FarPointer &pointer, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) :
        _hints( hints ),
        _operandType( OT_FAR_POINTER ),
        _farPointer( pointer ) {
    }

    Operand( const Address &address, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) :
        _hints( hints ),
        _operandType( OT_ADDRESS ),
        _address( address ) {
    }

    Operand( const Register &reg, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) :
        _hints( hints ),
        _operandType( OT_REGISTER ),
        _register( reg ) {
    }

public:

    bool operator==( const Operand &op ) const {
        if( &op == this ) {
            return true;
        }
        bool equal = false;
        switch( _operandType ) {
        case OT_ADDRESS:
            equal = _address == op._address;
            break;
        case OT_FAR_POINTER:
            equal = _farPointer == op._farPointer;
            break;
        case OT_IMMEDIATE:
            equal = _immediate == op._immediate;
            break;
        case OT_REGISTER:
            equal = _register == op._register;
            break;
        case OT_VIRTUAL:
            equal = true;
            break;
        case OT_NONE:
            equal = true;
            break;
        }
        return equal && op._hints == _hints && op._decorators == _decorators;
    }

    bool operator!=( const Operand &op ) const {
        return !(op == *this);
    }

public:

    void undef() {
        _operandType = OT_NONE;
    }

    void imm( const Integer &imm ) {
        _operandType = OT_IMMEDIATE;
        _immediate = imm;
    }

    void far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) {
        _operandType = OT_FAR_POINTER;
        _farPointer = FarPointer( seg, addr );
    }

    void far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) {
        _operandType = OT_FAR_POINTER;
        _farPointer = FarPointer( seg, addr );
    }

    void far_ptr( const FarPointer &pointer ) {
        _operandType = OT_FAR_POINTER;
        _farPointer = pointer;
    }

    void addr( const Address &address ) {
        _operandType = OT_ADDRESS;
        _address = address;
    }

    void off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        _operandType = OT_ADDRESS;
        _address = Address( offset, sizeOperator );
    }

    void addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        _operandType = OT_ADDRESS;
        _address = Address( effectiveAddress, sizeOperator );
    }

    void addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        _operandType = OT_ADDRESS;
        _address = Address( effectiveAddress, segmentSelector, sizeOperator );
    }

    void reg( const Register &reg ) {
        _operandType = OT_REGISTER;
        _register = reg;
    }

    void reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) {
        _operandType = OT_REGISTER;
        _register = Register( reg, size, type, x64_exp );
    }

public:

    bool isImm() const {
        return _operandType == OT_IMMEDIATE;
    }

    bool isReg() const {
        return _operandType == OT_REGISTER;
    }

    bool isAddr() const {
        return _operandType == OT_ADDRESS;
    }

    bool isFar() const {
        return _operandType == OT_FAR_POINTER;
    }

    const Address& getAddress() const {
        return _address;
    }

    Address& getAddress() {
        return _address;
    }

    Operand& setAddress( const Address &address ) {
        _address = address;
        return *this;
    }

    const FarPointer& getFarPointer() const {
        return _farPointer;
    }

    FarPointer& getFarPointer() {
        return _farPointer;
    }

    Operand& setFarPointer( const FarPointer &farPointer ) {
        _farPointer = farPointer;
        return *this;
    }

    const Integer& getImmediate() const {
        return _immediate;
    }

    Integer& getImmediate() {
        return _immediate;
    }

    Operand& setImmediate( const Integer &immediate ) {
        _immediate = immediate;
        return *this;
    }

    OperandType getOperandType() const {
        return _operandType;
    }

    Operand& setOperandType( OperandType operandType ) {
        _operandType = operandType;
        return *this;
    }

    const Register& getRegister() const {
        return _register;
    }

    Register& getRegister() {
        return _register;
    }

    Operand& setRegister( const Register &reg ) {
        this->_register = reg;
        return *this;
    }

    fcml_hints getHints() const {
       return _hints;
    }

    Operand& setHints( fcml_hints hints ) {
       _hints = hints;
       return *this;
    }

    const Decorators& getDecorators() const {
       return _decorators;
    }

    Decorators& getDecorators() {
       return _decorators;
    }

    Operand& setDecorators(const Decorators& decorators) {
       _decorators = decorators;
       return *this;
    }

    // Hints

    bool isMultimedia() const {
        return _hints & FCML_OP_HINT_MULTIMEDIA_INSTRUCTION;
    }

    bool isDisRelativeAddress() const {
        return ( _hints & FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS ) ? true : false;
    }

    bool isPseudoOpcode() const {
        return ( _hints & FCML_OP_HINT_PSEUDO_OPCODE ) ? true : false;
    }

    bool isAbsoluteAddressing() const {
        return ( _hints & FCML_OP_HINT_ABSOLUTE_ADDRESSING ) ? true : false;
    }

    bool isRelativeAddressing() const {
        return ( _hints & FCML_OP_HINT_RELATIVE_ADDRESSING ) ? true : false;
    }

    bool isSIBEncoding() const {
        return ( _hints & FCML_OP_HINT_SIB_ENCODING ) ? true : false;
    }

public:

    operator const Integer&() const {
        return _immediate;
    }

    operator const FarPointer&() const {
        return _farPointer;
    }

    operator const Address&() const {
        return _address;
    }

    operator const Register&() const {
        return _register;
    }

private:

    fcml_hints _hints;
    OperandType _operandType;
    Integer _immediate;
    FarPointer _farPointer;
    Address _address;
    Register _register;
    Decorators _decorators;

};

class OB {
public:

    static Operand undef() {
        return Operand();
    }

    static Operand imm( const Integer &imm ) {
        return Operand( imm );
    }

    static Operand far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) {
        return Operand( FarPointer( seg, addr ) );
    }

    static Operand far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) {
        return Operand( FarPointer( seg, addr ) );
    }

    static Operand far_ptr( const FarPointer &pointer ) {
        return Operand( pointer );
    }

    static Operand addr( const Address &address ) {
        return Operand( address );
    }

    static Operand off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return Operand( Address( offset, sizeOperator ) );
    }

    static Operand offb( const Integer &offset ) {
        return Operand( Address( offset, FCML_DS_8 ) );
    }

    static Operand offw( const Integer &offset ) {
        return Operand( Address( offset, FCML_DS_16 ) );
    }

    static Operand offd( const Integer &offset ) {
        return Operand( Address( offset, FCML_DS_32 ) );
    }

    static Operand offq( const Integer &offset ) {
        return Operand( Address( offset, FCML_DS_64 ) );
    }

    static Operand addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return Operand( Address( effectiveAddress, sizeOperator ) );
    }

    static Operand addrb( const EffectiveAddress &effectiveAddress ) {
        return Operand( Address( effectiveAddress, FCML_DS_8 ) );
    }

    static Operand addrw( const EffectiveAddress &effectiveAddress ) {
        return Operand( Address( effectiveAddress, FCML_DS_16 ) );
    }

    static Operand addrd( const EffectiveAddress &effectiveAddress ) {
        return Operand( Address( effectiveAddress, FCML_DS_32 ) );
    }

    static Operand addrq( const EffectiveAddress &effectiveAddress ) {
        return Operand( Address( effectiveAddress, FCML_DS_64 ) );
    }

    static Operand addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return Operand( Address( effectiveAddress, segmentSelector, sizeOperator ) );
    }

    static Operand addrb( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) {
        return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_8 ) );
    }

    static Operand addrw( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) {
        return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_16 ) );
    }

    static Operand addrd( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) {
        return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_32 ) );
    }

    static Operand addrq( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) {
        return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_64 ) );
    }

    static Operand reg( const Register &reg ) {
        return Operand( reg );
    }

    static Operand reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) {
        return Operand( Register( reg, size, type, x64_exp ) );
    }

    static Operand eff( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return addr( EffectiveAddress( displacement ), sizeOperator );
    }

    static Operand effb( const Integer &displacement ) {
        return addr( EffectiveAddress( displacement ), FCML_DS_8 );
    }

    static Operand effw( const Integer &displacement ) {
        return addr( EffectiveAddress( displacement ), FCML_DS_16 );
    }

    static Operand effd( const Integer &displacement ) {
        return addr( EffectiveAddress( displacement ), FCML_DS_32 );
    }

    static Operand effq( const Integer &displacement ) {
        return addr( EffectiveAddress( displacement ), FCML_DS_64 );
    }

    static Operand eff( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return addr( EffectiveAddress( base ), sizeOperator );
    }

    static Operand effb( const Register &base ) {
        return addr( EffectiveAddress( base ), FCML_DS_8 );
    }

    static Operand effw( const Register &base ) {
        return addr( EffectiveAddress( base ), FCML_DS_16 );
    }

    static Operand effd( const Register &base ) {
        return addr( EffectiveAddress( base ), FCML_DS_32 );
    }

    static Operand effq( const Register &base ) {
        return addr( EffectiveAddress( base ), FCML_DS_64 );
    }

    static Operand eff( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return addr( EffectiveAddress( base, displacement ), sizeOperator );
    }

    static Operand effb( const Register &base, const Integer &displacement ) {
        return addr( EffectiveAddress( base, displacement ), FCML_DS_8 );
    }

    static Operand effw( const Register &base, const Integer &displacement ) {
        return addr( EffectiveAddress( base, displacement ), FCML_DS_16 );
    }

    static Operand effd( const Register &base, const Integer &displacement ) {
        return addr( EffectiveAddress( base, displacement ), FCML_DS_32 );
    }

    static Operand effq( const Register &base, const Integer &displacement ) {
        return addr( EffectiveAddress( base, displacement ), FCML_DS_64 );
    }

    static Operand eff( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return addr( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator );
    }

    static Operand effb( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_8 );
    }

    static Operand effw( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_16 );
    }

    static Operand effd( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_32 );
    }

    static Operand effq( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_64 );
    }

    static Operand eff( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return addr( EffectiveAddress( base, index ), sizeOperator );
    }

    static Operand effb( const Register &base, const Register &index ) {
        return addr( EffectiveAddress( base, index ), FCML_DS_8 );
    }

    static Operand effw( const Register &base, const Register &index ) {
        return addr( EffectiveAddress( base, index ), FCML_DS_16 );
    }

    static Operand effd( const Register &base, const Register &index ) {
        return addr( EffectiveAddress( base, index ), FCML_DS_32 );
    }

    static Operand effq( const Register &base, const Register &index ) {
        return addr( EffectiveAddress( base, index ), FCML_DS_64 );
    }

    static Operand eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return addr( EffectiveAddress( base, index, scaleFactor ), sizeOperator );
    }

    static Operand effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_8 );
    }

    static Operand effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_16 );
    }

    static Operand effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_32 );
    }

    static Operand effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_64 );
    }

    static Operand eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        return addr( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator );
    }

    static Operand effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_8 );
    }

    static Operand effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_16 );
    }

    static Operand effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_32 );
    }

    static Operand effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_64 );
    }

};

class Condition {

public:

    enum ConditionType {
        CONDITION_O = FCML_CONDITION_O,
        CONDITION_B = FCML_CONDITION_B,
        CONDITION_E = FCML_CONDITION_E,
        CONDITION_BE = FCML_CONDITION_BE,
        CONDITION_S = FCML_CONDITION_S,
        CONDITION_P = FCML_CONDITION_P,
        CONDITION_L = FCML_CONDITION_L,
        CONDITION_LE = FCML_CONDITION_LE
    };

    Condition() :
        _conditionType(CONDITION_O),
        _isNegation(false) {
    }

    Condition( ConditionType type, bool negation = false ) :
        _conditionType( type ),
        _isNegation( negation ) {
    }

public:

    bool isO() const {
        return check( CONDITION_O );
    }

    static const Condition O() {
       const Condition condition( CONDITION_O );
       return condition;
    }

    bool isNO() const {
        return check( CONDITION_O, true );
    }

    static const Condition NO() {
       const Condition condition( CONDITION_O );
       return condition;
    }

    bool isB() const {
        return check( CONDITION_B );
    }

    static const Condition B() {
       const Condition condition( CONDITION_B );
       return condition;
    }

    bool isNB() const {
       return check( CONDITION_B, true );
    }

    static const Condition NB() {
       const Condition condition( CONDITION_B, true );
       return condition;
    }

    bool isNAE() const {
        return check( CONDITION_B );
    }

    static const Condition NAE() {
       const Condition condition( CONDITION_B );
       return condition;
    }

    bool isAE() const {
       return check( CONDITION_B, true );
    }

    static const Condition AE() {
       const Condition condition( CONDITION_B, true );
       return condition;
    }

    bool isC() const {
        return check( CONDITION_B );
    }

    static const Condition C() {
       const Condition condition( CONDITION_B );
       return condition;
    }

    bool isNC() const {
        return check( CONDITION_B, true );
    }

    static const Condition NC() {
       const Condition condition( CONDITION_B, true );
       return condition;
    }

    bool isE() const {
        return check( CONDITION_E );
    }

    static const Condition E() {
       const Condition condition( CONDITION_E );
       return condition;
    }

    bool isZ() const {
        return check( CONDITION_E );
    }

    static const Condition Z() {
       const Condition condition( CONDITION_E );
       return condition;
    }

    bool isNE() const {
        return check( CONDITION_E, true );
    }

    static const Condition NE() {
       const Condition condition( CONDITION_E, true );
       return condition;
    }

    bool isNZ() const {
        return check( CONDITION_E, true );
    }

    static const Condition NZ() {
       const Condition condition( CONDITION_E, true );
       return condition;
    }

    bool isBE() const {
        return check( CONDITION_BE );
    }

    static const Condition BE() {
       const Condition condition( CONDITION_BE );
       return condition;
    }

    bool isNA() const {
        return check( CONDITION_BE );
    }

    static const Condition NA() {
       const Condition condition( CONDITION_BE );
       return condition;
    }

    bool isNBE() const {
        return check( CONDITION_BE, true );
    }

    static const Condition NBE() {
       const Condition condition( CONDITION_BE, true );
       return condition;
    }

    bool isA() const {
        return check( CONDITION_BE, true );
    }

    static const Condition A() {
       const Condition condition( CONDITION_BE, true );
       return condition;
    }

    bool isS() const {
        return check( CONDITION_S );
    }

    static const Condition S() {
       const Condition condition( CONDITION_S );
       return condition;
    }

    bool isNS() const {
        return check( CONDITION_S, true );
    }

    static const Condition NS() {
       const Condition condition( CONDITION_S, true );
       return condition;
    }

    bool isP() const {
        return check( CONDITION_P );
    }

    static const Condition P() {
       const Condition condition( CONDITION_P );
       return condition;
    }

    bool isPE() const {
        return check( CONDITION_P );
    }

    static const Condition PE() {
       const Condition condition( CONDITION_P );
       return condition;
    }

    bool isNP() const {
        return check( CONDITION_P, true );
    }

    static const Condition NP() {
       const Condition condition( CONDITION_P, true );
       return condition;
    }

    bool isPO() const {
        return check( CONDITION_P, true );
    }

    static const Condition PO() {
       const Condition condition( CONDITION_P, true );
       return condition;
    }

    bool isL() const {
        return check( CONDITION_L );
    }

    static const Condition L() {
       const Condition condition( CONDITION_L );
       return condition;
    }

    bool isNGE() const {
        return check( CONDITION_L );
    }

    static const Condition NGE() {
       const Condition condition( CONDITION_L );
       return condition;
    }

    bool isNL() const {
        return check( CONDITION_L, true );
    }

    static const Condition NL() {
       const Condition condition( CONDITION_L, true );
       return condition;
    }

    bool isGE() const {
        return check( CONDITION_L, true );
    }

    static const Condition GE() {
       const Condition condition( CONDITION_L, true );
       return condition;
    }

    bool isLE() const {
        return check( CONDITION_LE );
    }

    static const Condition LE() {
       const Condition condition( CONDITION_LE );
       return condition;
    }

    bool isNG() const {
        return check( CONDITION_LE );
    }

    static const Condition NG() {
       const Condition condition( CONDITION_LE );
       return condition;
    }

    bool isNLE() const {
        return check( CONDITION_LE, true );
    }

    static const Condition NLE() {
       const Condition condition( CONDITION_LE, true );
       return condition;
    }

    bool isG() const {
        return check( CONDITION_LE, true );
    }

    static const Condition G() {
       const Condition condition( CONDITION_LE, true );
       return condition;
    }

public:

    bool operator==( const Condition &cond ) const {
        return cond._conditionType == _conditionType && cond._isNegation == _isNegation;
    }

    bool operator!=( const Condition &cond ) const {
        return !(*this == cond);
    }

public:

    ConditionType getConditionType() const {
        return _conditionType;
    }

    Condition& setConditionType( ConditionType conditionType ) {
        _conditionType = conditionType;
        return *this;
    }

    bool isNegation() const {
        return _isNegation;
    }

    Condition& setNegation( bool isNegation ) {
        _isNegation = isNegation;
        return *this;
    }

private:

    bool check( ConditionType type, bool negation = false ) const {
        return _conditionType == type && _isNegation == negation;
    }

private:

    /* Condition type.*/
    ConditionType _conditionType;
    /* True if condition should be negated.*/
    bool _isNegation;

};

class Instruction {
public:

    Instruction() :
        _prefixes(0),
        _hints(FCML_HINT_NO_HINTS),
        _isConditional(false),
        _operandsCount(0) {
    }

    Instruction( const fcml_cstring &mnemonic ) :
        _prefixes(0),
        _hints(FCML_HINT_NO_HINTS),
        _mnemonic(mnemonic),
        _isConditional(false),
        _operandsCount(0) {
    }

public:

    void add( const Operand &operand ) {
        if( _operandsCount == FCML_OPERANDS_COUNT ) {
            throw IllegalStateException( FCML_TEXT( "No more operands allowed." ) );
        }
        _operands[_operandsCount++] = operand;
    }

    void setOperand( const Operand &operand, fcml_int index ) {
        if( index >= FCML_OPERANDS_COUNT ) {
            throw IllegalStateException( FCML_TEXT( "Operand's number exceeds maximal number of operands allowed." ) );
        }
        _operands[index] = operand;
    }

    const Operand & operator[]( fcml_int index ) const {
        checkArrayAccess(index);
        return _operands[index];
    }

    Operand & operator[]( fcml_int index ) {
        checkArrayAccess(index);
        return _operands[index];
    }

    void clean() {
        for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) {
            // Clean the operand.
            _operands[i] = Operand();
        }
        _operandsCount = 0;
    }

public:

    const Condition& getCondition() const {
        return _condition;
    }

    Condition& getCondition() {
        return _condition;
    }

    Instruction& setCondition( const Condition &condition ) {
        _condition = condition;
        return *this;
    }

    fcml_hints getHints() const {
        return _hints;
    }

    Instruction& setHints( fcml_hints hints ) {
        _hints = hints;
        return *this;
    }

    bool isConditional() const {
        return _isConditional;
    }

    Instruction& setConditional( bool isConditional ) {
        _isConditional = isConditional;
        return *this;
    }

    const fcml_cstring& getMnemonic() const {
        return _mnemonic;
    }

    Instruction& setMnemonic( const fcml_cstring &mnemonic ) {
        _mnemonic = mnemonic;
        return *this;
    }

    fcml_int getOperandsCount() const {
        return _operandsCount;
    }

    Instruction& setOperandsCount( fcml_int operandsCount ) {
        _operandsCount = operandsCount;
        return *this;
    }

    fcml_prefixes getPrefixes() const {
        return _prefixes;
    }

    Instruction& setPrefixes( fcml_prefixes prefixes ) {
        _prefixes = prefixes;
        return *this;
    }

public:

    // Helper methods to identify prefixes and hints.

    bool isLock() const {
        return ( _prefixes & FCML_PREFIX_LOCK ) ? true : false;
    }

    bool isRepne() const {
        return ( _prefixes & FCML_PREFIX_REPNE ) ? true : false;
    }

    bool isRepnz() const {
        return ( _prefixes & FCML_PREFIX_REPNZ ) ? true : false;
    }

    bool isRep() const {
        return ( _prefixes & FCML_PREFIX_REP ) ? true : false;
    }

    bool isRepe() const {
        return ( _prefixes & FCML_PREFIX_REPE ) ? true : false;
    }

    bool isRepz() const {
        return ( _prefixes & FCML_PREFIX_REPZ ) ? true : false;
    }

    bool isXAcquire() const {
        return ( _prefixes & FCML_PREFIX_XACQUIRE ) ? true : false;
    }

    bool isXRelease() const {
        return ( _prefixes & FCML_PREFIX_XRELEASE ) ? true : false;
    }

    bool isBranchHint() const {
        return ( _prefixes & FCML_PREFIX_BRANCH_HINT ) ? true : false;
    }

    bool isNoBranchHint() const {
        return ( _prefixes & FCML_PREFIX_NOBRANCH_HINT ) ? true : false;
    }

    bool isFarPointer() const {
        return ( _hints & FCML_HINT_FAR_POINTER ) ? true : false;
    }

    bool isNearPointer() const {
        return ( _hints & FCML_HINT_NEAR_POINTER ) ? true : false;
    }

    bool isLongFormPointer() const {
        return ( _hints & FCML_HINT_LONG_FORM_POINTER ) ? true : false;
    }

    bool isIndirectPointer() const {
        return ( _hints & FCML_HINT_INDIRECT_POINTER ) ? true : false;
    }

    bool isDirectPointer() const {
        return ( _hints & FCML_HINT_DIRECT_POINTER ) ? true : false;
    }

private:

    void checkArrayAccess( fcml_int index) const {
        if( index < 0 || index >= FCML_OPERANDS_COUNT ) {
            throw BadArgumentException( FCML_TEXT( "Index exceeds the allowed number of operands." ) );
        }
    }

private:

    fcml_prefixes _prefixes;
    fcml_hints _hints;
    fcml_cstring _mnemonic;
    bool _isConditional;
    Condition _condition;
    Operand _operands[FCML_OPERANDS_COUNT];
    fcml_int _operandsCount;

};

class IB {

public:

    IB( const fcml_cstring &mnemonic ) :
        _hints(FCML_HINT_NO_HINTS),
        _prefixes(0),
        _mnemonic(mnemonic),
        _operandsCount(0) {
    }

    IB( fcml_prefixes prefixes, const fcml_cstring &mnemonic ) :
        _hints(FCML_HINT_NO_HINTS),
        _prefixes(prefixes),
        _mnemonic(mnemonic),
        _operandsCount(0) {
    }

    IB( const fcml_cstring &mnemonic, fcml_hints hints) :
        _hints(hints),
        _prefixes(0),
        _mnemonic(mnemonic),
        _operandsCount(0) {
    }

    IB( fcml_prefixes prefixes, const fcml_cstring &mnemonic, fcml_hints hints ) :
        _hints(hints),
        _prefixes(prefixes),
        _mnemonic(mnemonic),
        _operandsCount(0) {
    }

    operator Instruction() const {
        return build();
    }

    Instruction build() const {
        Instruction instruction(_mnemonic);
        instruction.setHints(_hints);
        instruction.setPrefixes(_prefixes);
        instruction.setOperandsCount(_operandsCount);
        for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) {
            instruction.setOperand( _operands[i], i );
        }
        return instruction;
    }

    void op( const Operand &operand ) {
        if( _operandsCount == FCML_OPERANDS_COUNT ) {
            throw IllegalStateException( FCML_TEXT( "No more operands allowed." ) );
        }
        _operands[_operandsCount++] = operand;
    }

    static IB inst( const fcml_cstring &mnemonic ) {
        return IB(mnemonic);
    }

    // Hints.

    static const InstructionHint FAR_PTR() {
        return InstructionHint::FAR_POINTER();
    }

    IB& farPtr() {
        _hints |= FCML_HINT_FAR_POINTER;
        return *this;
    }

    static const InstructionHint NEAR_PTR() {
        return InstructionHint::NEAR_POINTER();
    }

    IB& nearPtr() {
        _hints |= FCML_HINT_NEAR_POINTER;
        return *this;
    }

    static const InstructionHint LONG_FORM_PTR() {
        return InstructionHint::LONG_FORM_POINTER();
    }

    IB& longFormPtr() {
        _hints |= FCML_HINT_LONG_FORM_POINTER;
        return *this;
    }

    static const InstructionHint INDIRECT_PTR() {
        return InstructionHint::INDIRECT_POINTER();
    }

    IB& indirectPtr() {
        _hints |= FCML_HINT_INDIRECT_POINTER;
        return *this;
    }

    static const InstructionHint DIRECT_PTR() {
        return InstructionHint::DIRECT_POINTER();
    }

    IB& directPtr() {
        _hints |= FCML_HINT_DIRECT_POINTER;
        return *this;
    }

    // Prefixes.

    static const InstructionPrefix LOCK() {
        return InstructionPrefix::LOCK();
    }

    IB& lock() {
        _prefixes |= FCML_PREFIX_LOCK;
        return *this;
    }

    static const InstructionPrefix REPNE() {
        return InstructionPrefix::REPNE();
    }

    IB& repne() {
        _prefixes |= FCML_PREFIX_REPNE;
        return *this;
    }

    static const InstructionPrefix REPNZ() {
        return InstructionPrefix::REPNZ();
    }

    IB& repnz() {
        _prefixes |= FCML_PREFIX_REPNZ;
        return *this;
    }

    static const InstructionPrefix REP() {
        return InstructionPrefix::REP();
    }

    IB& rep() {
        _prefixes |= FCML_PREFIX_REP;
        return *this;
    }

    static const InstructionPrefix REPE() {
        return InstructionPrefix::REPE();
    }

    IB& repe() {
        _prefixes |= FCML_PREFIX_REPE;
        return *this;
    }

    static const InstructionPrefix REPZ() {
        return InstructionPrefix::REPZ();
    }

    IB& repz() {
        _prefixes |= FCML_PREFIX_REPZ;
        return *this;
    }

    static const InstructionPrefix XACQUIRE() {
        return InstructionPrefix::XACQUIRE();
    }

    IB& xacquire() {
        _prefixes |= FCML_PREFIX_XACQUIRE;
        return *this;
    }

    static const InstructionPrefix XRELEASE() {
        return InstructionPrefix::XRELEASE();
    }

    IB& xrelease() {
        _prefixes |= FCML_PREFIX_XRELEASE;
        return *this;
    }

    static const InstructionPrefix BRANCH() {
        return InstructionPrefix::BRANCH_HINT();
    }

    IB& branchHint() {
        _prefixes |= FCML_PREFIX_BRANCH_HINT;
        return *this;
    }

    static const InstructionPrefix NO_BRANCH() {
        return InstructionPrefix::NOBRANCH_HINT();
    }

    IB& nobranchHint() {
        _prefixes |= FCML_PREFIX_NOBRANCH_HINT;
        return *this;
    }

    static const OperandHint OP_MULTIMEDIA_HINT() {
        return OperandHint::MULTIMEDIA();
    }

    static const OperandHint OP_RELATIVE_ADDRESSING() {
        return OperandHint::RELATIVE_ADDRESSING();
    }

    static const OperandHint OP_ABSOLUTE_ADDRESSING() {
        return OperandHint::ABSOLUTE_ADDRESSING();
    }

    static const OperandHint OP_SIB_ENCODING() {
        return OperandHint::SIB_ENCODING();
    }

    IB& operandMultimediaHint() {
        set( OP_MULTIMEDIA_HINT() );
        return *this;
    }

    IB& operandRelativeHint() {
        set( OP_MULTIMEDIA_HINT() );
        return *this;
    }

    IB& operandAbsoluteHint() {
        set( OP_MULTIMEDIA_HINT() );
        return *this;
    }

    IB& operandSIBEncodingHint() {
        set( OP_MULTIMEDIA_HINT() );
        return *this;
    }

    // Operands.

    IB& imm( const Integer &imm ) {
        sanityCheck();
        _operands[_operandsCount++].imm(imm);
        return *this;
    }

    IB& far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) {
        sanityCheck();
        _operands[_operandsCount++].far_ptr(seg, addr);
        return *this;
    }

    IB& far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) {
        sanityCheck();
        _operands[_operandsCount++].far_ptr(seg, addr);
        return *this;
    }

    IB& far_ptr( const FarPointer &pointer ) {
        sanityCheck();
        _operands[_operandsCount++].far_ptr( pointer );
        return *this;
    }

    IB& addr( const Address &address ) {
        sanityCheck();
        _operands[_operandsCount++].addr(address);
        return *this;
    }

    IB& off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        sanityCheck();
        _operands[_operandsCount++].off( offset, sizeOperator );
        return *this;
    }

    IB& offb( const Integer &offset ) {
        sanityCheck();
        _operands[_operandsCount++].off( offset, FCML_DS_8 );
        return *this;
    }

    IB& offw( const Integer &offset ) {
        sanityCheck();
        _operands[_operandsCount++].off( offset, FCML_DS_16 );
        return *this;
    }

    IB& offd( const Integer &offset ) {
        sanityCheck();
        _operands[_operandsCount++].off( offset, FCML_DS_32 );
        return *this;
    }

    IB& offq( const Integer &offset ) {
        sanityCheck();
        _operands[_operandsCount++].off( offset, FCML_DS_64 );
        return *this;
    }

    IB& addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, sizeOperator );
        return *this;
    }

    IB& addrb( const EffectiveAddress &effectiveAddress ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_8 );
        return *this;
    }

    IB& addrw( const EffectiveAddress &effectiveAddress ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_16 );
        return *this;
    }

    IB& addrd( const EffectiveAddress &effectiveAddress ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_32 );
        return *this;
    }

    IB& addrq( const EffectiveAddress &effectiveAddress ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_64 );
        return *this;
    }

    IB& addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, sizeOperator );
        return *this;
    }

    IB& addrb( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 );
        return *this;
    }

    IB& addrw( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 );
        return *this;
    }

    IB& addrd( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 );
        return *this;
    }

    IB& addrq( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) {
        sanityCheck();
        _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 );
        return *this;
    }

    IB& reg( const Register &reg ) {
        sanityCheck();
        _operands[_operandsCount++].reg( reg );
        return *this;
    }

    IB& reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) {
        sanityCheck();
        _operands[_operandsCount++].reg( Register( reg, size, type, x64_exp ) );
        return *this;
    }

    IB& eff( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        next().addr( EffectiveAddress(displacement), sizeOperator );
        return *this;
    }

    IB& effb( const Integer &displacement ) {
        next().addr( EffectiveAddress(displacement), FCML_DS_8 );
        return *this;
    }

    IB& effw( const Integer &displacement ) {
        next().addr( EffectiveAddress(displacement), FCML_DS_16 );
        return *this;
    }

    IB& effd( const Integer &displacement ) {
        next().addr( EffectiveAddress(displacement), FCML_DS_32 );
        return *this;
    }

    IB& effq( const Integer &displacement ) {
        next().addr( EffectiveAddress(displacement), FCML_DS_64 );
        return *this;
    }

    IB& eff( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        next().addr( EffectiveAddress(base), sizeOperator );
        return *this;
    }

    IB& effb( const Register &base ) {
        next().addr( EffectiveAddress(base), FCML_DS_8 );
        return *this;
    }

    IB& effw( const Register &base ) {
        next().addr( EffectiveAddress(base), FCML_DS_16 );
        return *this;
    }

    IB& effd( const Register &base ) {
        next().addr( EffectiveAddress(base), FCML_DS_32 );
        return *this;
    }

    IB& effq( const Register &base ) {
        next().addr( EffectiveAddress(base), FCML_DS_64 );
        return *this;
    }

    IB& eff( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        next().addr( EffectiveAddress( base, displacement ), sizeOperator );
        return *this;
    }

    IB& effb( const Register &base, const Integer &displacement ) {
        next().addr( EffectiveAddress( base, displacement ), FCML_DS_8 );
        return *this;
    }

    IB& effw( const Register &base, const Integer &displacement ) {
        next().addr( EffectiveAddress( base, displacement ), FCML_DS_16 );
        return *this;
    }

    IB& effd( const Register &base, const Integer &displacement ) {
        next().addr( EffectiveAddress( base, displacement ), FCML_DS_32 );
        return *this;
    }

    IB& effq( const Register &base, const Integer &displacement ) {
        next().addr( EffectiveAddress( base, displacement ), FCML_DS_64 );
        return *this;
    }

    IB& eff( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
           next().addr( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator );
           return *this;
       }

    IB& effb( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
           next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_8 );
           return *this;
       }

    IB& effw( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_16 );
        return *this;
    }

    IB& effd( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_32 );
        return *this;
    }

    IB& effq( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_64 );
        return *this;
    }

    IB& eff( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        next().addr( EffectiveAddress( base, index ), sizeOperator );
        return *this;
    }

    IB& effb( const Register &base, const Register &index ) {
        next().addr( EffectiveAddress( base, index ), FCML_DS_8 );
        return *this;
    }

    IB& effw( const Register &base, const Register &index ) {
        next().addr( EffectiveAddress( base, index ), FCML_DS_16 );
        return *this;
    }

    IB& effd( const Register &base, const Register &index ) {
        next().addr( EffectiveAddress( base, index ), FCML_DS_32 );
        return *this;
    }

    IB& effq( const Register &base, const Register &index ) {
        next().addr( EffectiveAddress( base, index ), FCML_DS_64 );
        return *this;
    }

    IB& eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        next().addr( EffectiveAddress( base, index, scaleFactor ), sizeOperator );
        return *this;
    }

    IB& effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_8 );
        return *this;
    }

    IB& effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_16 );
        return *this;
    }

    IB& effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_32 );
        return *this;
    }

    IB& effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) {
        next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_64 );
        return *this;
    }

    IB& eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) {
        next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator );
        return *this;
    }

    IB& effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_8 );
        return *this;
    }

    IB& effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_16 );
        return *this;
    }

    IB& effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_32 );
        return *this;
    }

    IB& effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) {
        next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_64 );
        return *this;
    }

    IB& operator <<(const Operand &operand) {
        next() = operand;
        return *this;
    }

    IB& operator <<(const InstructionPrefix &prefix) {
        return set(prefix);
    }

    IB& operator <<(const InstructionHint &hint) {
        return set( hint );
    }

    IB& operator <<(const OperandHint &hint) {
       return set( hint );
    }

    IB& set( const InstructionPrefix &prefix ) {
        _prefixes |= prefix._prefix;
        return *this;
    }

    IB& set( const InstructionHint &hint ) {
        _hints |= hint._hint;
        return *this;
    }

    IB& set( const OperandHint &hint ) {
        if( _operandsCount == 0 ) {
            throw IllegalStateException( FCML_TEXT( "There are no operands yet for the current instruction.." ) );
        }
        _operands[_operandsCount-1].setHints( _operands[_operandsCount-1].getHints() | hint._hint );
        return *this;
    }

private:

    Operand& next() {
        sanityCheck();
        return _operands[_operandsCount++];
    }

    void sanityCheck() const {
        if( _operandsCount == FCML_OPERANDS_COUNT ) {
            throw IllegalStateException( FCML_TEXT( "Operand's number exceeds maximal number of operands allowed." ) );
        }
    }

private:

    fcml_hints _hints;
    fcml_prefixes _prefixes;
    fcml_cstring _mnemonic;
    fcml_int _operandsCount;
    Operand _operands[FCML_OPERANDS_COUNT];

};

class TypeConverter {
public:

    static void convert( const fcml_st_entry_point &src, EntryPoint &dest ) {
        dest.setIP( src.ip );
        dest.setOpMode( static_cast<EntryPoint::OperatingMode>( src.op_mode ) );
        dest.setAddressSizeAttribute( src.address_size_attribute );
        dest.setOperandSizeAttribute( src.operand_size_attribute );
    }

    static void convert( const EntryPoint &src, fcml_st_entry_point &dest ) {
        dest.ip = src.getIP();
        dest.op_mode = static_cast<fcml_en_operating_mode>( src.getOpMode() );
        dest.address_size_attribute = src.getAddressSizeAttribute();
        dest.operand_size_attribute = src.getOperandSizeAttribute();
    }

    static void convert( const fcml_st_integer &src, Integer &dest ) {
        dest.setInt8( src.int8 );
        dest.setInt16( src.int16 );
        dest.setInt32( src.int32 );
        dest.setInt64( src.int64 );
        dest.setSigned( src.is_signed );
        dest.setSize( src.size );
    }

    static void convert( const Integer &src, fcml_st_integer &dest ) {
        dest.int8 = src.getInt8();
        dest.int16 = src.getInt16();
        dest.int32 = src.getInt32();
        dest.int64 = src.getInt64();
        dest.is_signed = src.isSigned();
        dest.size = src.getSize();
    }

    static void convert( const fcml_st_offset &src, Integer &dest ) {
        dest.setInt16( src.off16 );
        dest.setInt32( src.off32 );
        dest.setInt64( src.off64 );
        dest.setSigned( src.is_signed );
        dest.setSize( src.size );
    }

    static void convert( const Integer &src, fcml_st_offset &dest ) {
        dest.off16 = src.getSize() == FCML_DS_8 ? src.getInt8() : src.getInt16();
        dest.off32 = src.getInt32();
        dest.off64 = src.getInt64();
        dest.is_signed = src.isSigned();
        dest.size = src.getSize();
    }

    static void convert( const fcml_st_register &src, Register &dest ) {
        dest.setReg( src.reg );
        dest.setSize( src.size );
        dest.setType( static_cast<Register::RegisterType>( src.type ) );
        dest.setX64Exp( src.x64_exp ? true : false );
    }

    static void convert( const Register &src, fcml_st_register &dest ) {
        dest.reg = src.getReg();
        dest.size = src.getSize();
        dest.type = static_cast<fcml_en_register>( src.getType() );
        dest.x64_exp = src.getX64Exp();
    }

    static void convert( const fcml_st_far_pointer &src, FarPointer &dest ) {
        dest.setOffset16( src.offset16 );
        dest.setOffset32( src.offset32 );
        dest.setOffsetSize( src.offset_size );
        dest.setSegment( src.segment );
    }

    static void convert( const FarPointer &src, fcml_st_far_pointer &dest ) {
        dest.offset16 = src.getOffset16();
        dest.offset32 = src.getOffset32();
        dest.offset_size = src.getOffsetSize();
        dest.segment = src.getSegment();
    }

    static void convert( const fcml_st_segment_selector &src, SegmentSelector &dest ) {
        dest.setDefaultReg( src.is_default_reg ? true : false );
        convert( src.segment_selector, dest.getSegmentSelector() );
    }

    static void convert( const SegmentSelector &src, fcml_st_segment_selector &dest ) {
        dest.is_default_reg = src.isDefaultReg();
        convert( src.getSegmentSelector(), dest.segment_selector );
    }

    static void convert( const fcml_st_effective_address &src, EffectiveAddress &dest ) {
        convert( src.base, dest.getBase() );
        convert( src.index, dest.getIndex() );
        convert( src.displacement, dest.getDisplacement() );
        dest.setScaleFactor(src.scale_factor);
    }

    static void convert( const EffectiveAddress &src, fcml_st_effective_address &dest ) {
        convert( src.getBase(), dest.base );
        convert( src.getIndex(), dest.index );
        convert( src.getDisplacement(), dest.displacement );
        dest.scale_factor = src.getScaleFactor();
    }

    static void convert( const fcml_st_address &src, Address &dest ) {
        dest.setAddressForm( static_cast<Address::AddressForm>( src.address_form ) );
        dest.setSizeOperator( src.size_operator );
        convert( src.segment_selector, dest.getSegmentSelector() );
        convert( src.effective_address, dest.getEffectiveAddress() );
        convert( src.offset, dest.getOffset() );
    }

    static void convert( const Address &src, fcml_st_address &dest ) {
        dest.address_form = static_cast<fcml_en_effective_address_form>( src.getAddressForm() );
        dest.size_operator = src.getSizeOperator();
        convert( src.getSegmentSelector(), dest.segment_selector );
        convert( src.getEffectiveAddress(), dest.effective_address );
        convert( src.getOffset(), dest.offset );
    }

    static void convert(const fcml_st_operand &src, Operand &dest) {
        dest.setHints(src.hints);
        dest.setOperandType(static_cast<Operand::OperandType>(src.type));
        convert(src.address, dest.getAddress());
        convert(src.far_pointer, dest.getFarPointer());
        convert(src.immediate, dest.getImmediate());
        convert(src.reg, dest.getRegister());
        convert(src.decorators, dest.getDecorators());
    }

    static void convert(const Operand &src, fcml_st_operand &dest) {
        dest.hints = src.getHints();
        dest.type = static_cast<fcml_en_operand_type>(src.getOperandType());
        convert(src.getAddress(), dest.address);
        convert(src.getFarPointer(), dest.far_pointer);
        convert(src.getImmediate(), dest.immediate);
        convert(src.getRegister(), dest.reg);
        convert(src.getDecorators(), dest.decorators);
    }

    static void convert(const fcml_st_operand_decorators &src,
            Decorators &dest) {
        Nullable<fcml_uint8_t> bcast;
        bcast.setNotNull(FCML_TO_CPP_BOOL(src.bcast.is_not_null));
        bcast.setValue(src.bcast.value);
        dest.setBcast(bcast);
        Nullable<Decorators::EmbeededRoundingControl> er;
        er.setNotNull(FCML_TO_CPP_BOOL(src.er.is_not_null));
        er.setValue(static_cast<Decorators::EmbeededRoundingControl>(src.er.value));
        dest.setEr(er);
        dest.setZ(src.z);
        dest.setSae(src.sae);
        convert(src.operand_mask_reg, dest.getOpmaskReg());
    }

    static void convert(const Decorators &src, fcml_st_operand_decorators &dest) {
        dest.bcast.is_not_null = src.getBcast().isNotNull();
        dest.bcast.value = src.getBcast().getValue();
        dest.er.is_not_null = src.getEr().isNotNull();
        dest.er.value = static_cast<fcml_uint8_t>(src.getEr().getValue());
        dest.z = src.isZ();
        dest.sae = src.isSae();
        convert(src.getOpmaskReg(), dest.operand_mask_reg);
    }

    static void convert( const fcml_st_condition &src, Condition &dest ) {
        dest.setConditionType( static_cast<Condition::ConditionType>( src.condition_type ) );
        dest.setNegation( src.is_negation ? true : false );
    }

    static void convert( const Condition &src, fcml_st_condition &dest ) {
        dest.condition_type = static_cast<fcml_en_condition_type>( src.getConditionType() );
        dest.is_negation = src.isNegation();
    }

    static void convert( const fcml_st_instruction &src, Instruction &dest ) {
        dest.setMnemonic( src.mnemonic );
        convert( src.condition, dest.getCondition() );
        dest.setHints( src.hints );
        dest.setPrefixes( src.prefixes );
        dest.setConditional( src.is_conditional ? true : false );
        for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) {
            convert( src.operands[i], dest[i] );
        }
        dest.setOperandsCount(src.operands_count);
    }

    static void convert( const Instruction &src, fcml_st_instruction &dest ) {
        // Bear in mind that you are responsible for freeing mnemonic duplicated here.
        dest.mnemonic = Env::strDup( src.getMnemonic().c_str() );
        convert( src.getCondition(), dest.condition );
        dest.hints = src.getHints();
        dest.prefixes = src.getPrefixes();
        dest.is_conditional = src.isConditional();
        for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) {
            convert( src[i], dest.operands[i] );
        }
        dest.operands_count = src.getOperandsCount();
    }

    static void free( fcml_st_instruction &instruction ) {
        if( instruction.mnemonic ) {
            Env::strFree( instruction.mnemonic );
            instruction.mnemonic = NULL;
        }
    }
};

}

#endif //FCML_COMMON_HPP_