@instruction<EOL><INDENT>def LSS(cpu, dest, src):<DEDENT>
raise NotImplementedError("<STR_LIT>")<EOL>
Loads far pointer.

Loads a far pointer (segment selector and offset) from the second operand
(source operand) into a segment register and the first operand (destination
operand). The source operand specifies a 48-bit or a 32-bit pointer in
memory depending on the current setting of the operand-size attribute
(32 bits or 16 bits, respectively). The instruction opcode and the destination
operand specify a segment register/general-purpose register pair. The
16-bit segment selector from the source operand is loaded into the segment
register specified with the opcode (DS, SS, ES, FS, or GS). The 32-bit
or 16-bit offset is loaded into the register specified with the destination
operand.
In 64-bit mode, the instruction's default operation size is 32 bits. Using a
REX prefix in the form of REX.W promotes operation to specify a source operand
referencing an 80-bit pointer (16-bit selector, 64-bit offset) in memory.
If one of these instructions is executed in protected mode, additional
information from the segment descriptor pointed to by the segment selector
in the source operand is loaded in the hidden part of the selected segment
register.
Also in protected mode, a null selector (values 0000 through 0003) can
be loaded into DS, ES, FS, or GS registers without causing a protection
exception. (Any subsequent reference to a segment whose corresponding
segment register is loaded with a null selector, causes a general-protection
exception (#GP) and no memory reference to the segment occurs.)::

        IF ProtectedMode
        THEN IF SS is loaded
            THEN IF SegementSelector  =  null
                THEN #GP(0);
                FI;
            ELSE IF Segment selector index is not within descriptor table limits
                OR Segment selector RPL  CPL
                OR Access rights indicate nonwritable data segment
                OR DPL  CPL
                THEN #GP(selector);
                FI;
            ELSE IF Segment marked not present
                THEN #SS(selector);
                FI;
                SS  =  SegmentSelector(SRC);
                SS  =  SegmentDescriptor([SRC]);
            ELSE IF DS, ES, FS, or GS is loaded with non-null segment selector
                THEN IF Segment selector index is not within descriptor table limits
                    OR Access rights indicate segment neither data nor readable code segment
                    OR Segment is data or nonconforming-code segment
                    AND both RPL and CPL > DPL)
                    THEN #GP(selector);
                    FI;
                ELSE IF Segment marked not present
                    THEN #NP(selector);
                    FI;
                    SegmentRegister  =  SegmentSelector(SRC) AND RPL;
                    SegmentRegister  =  SegmentDescriptor([SRC]);
                ELSE IF DS, ES, FS, or GS is loaded with a null selector:
                    SegmentRegister  =  NullSelector;
                    SegmentRegister(DescriptorValidBit)  =  0; (*hidden flag; not accessible by software*)
                FI;
            FI;
            IF (Real-Address or Virtual-8086 Mode)
            THEN
                SegmentRegister  =  SegmentSelector(SRC);
            FI;
            DEST  =  Offset(SRC);