ABSolute value : Set $t1 to absolute value of $t2 (algorithm from Hacker’s Delight)
| Parameters: |
|
|---|
ADDition : set $t1 to ($t2 plus 16-bit immediate)
| Parameters: |
|
|---|
ADDition : set $t1 to ($t2 plus 32-bit immediate)
| Parameters: |
|
|---|
ADDition Immediate : set $t1 to ($t2 plus 32-bit immediate)
| Parameters: |
|
|---|
ADDition Immediate Unsigned: set $t1 to ($t2 plus 32-bit immediate), no overflow
| Parameters: |
|
|---|
ADDition Unsigned : set $t1 to ($t2 plus 32-bit immediate), no overflow
| Parameters: |
|
|---|
AND : set $t1 to ($t2 bitwise-AND 16-bit unsigned immediate)
| Parameters: |
|
|---|
AND : set $t1 to ($t1 bitwise-AND 16-bit unsigned immediate)
| Parameters: |
|
|---|
AND Immediate : set $t1 to ($t2 bitwise-AND 32-bit immediate)
| Parameters: |
|
|---|
AND Immediate : set $t1 to ($t1 bitwise-AND 16-bit unsigned immediate)
| Parameters: |
|
|---|
AND Immediate : set $t1 to ($t1 bitwise-AND 32-bit immediate)
| Parameters: |
|
|---|
Branch : Branch to statement at label unconditionally
| Parameters: |
|
|---|
Branch if EQual : Branch to statement at label if $t1 is equal to 16-bit immediate
| Parameters: |
|
|---|
Branch if EQual : Branch to statement at label if $t1 is equal to 32-bit immediate
| Parameters: |
|
|---|
Branch if EQual Zero : Branch to statement at label if $t1 is equal to zero
| Parameters: |
|
|---|
Branch if Greater or Equal : Branch to statement at label if $t1 is greater or equal to $t2
| Parameters: |
|
|---|
Branch if Greater or Equal : Branch to statement at label if $t1 is greater or equal to 16-bit immediate
| Parameters: |
|
|---|
Branch if Greater or Equal : Branch to statement at label if $t1 is greater or equal to 32-bit immediate
| Parameters: |
|
|---|
Branch if Greater or Equal Unsigned : Branch to statement at label if $t1 is greater or equal to $t2 (unsigned compare)
| Parameters: |
|
|---|
Branch if Greater or Equal Unsigned : Branch to statement at label if $t1 is greater or equal to 16-bit immediate (unsigned compare)
| Parameters: |
|
|---|
Branch if Greater or Equal Unsigned : Branch to statement at label if $t1 is greater or equal to 32-bit immediate (unsigned compare)
| Parameters: |
|
|---|
Branch if Greater Than : Branch to statement at label if $t1 is greater than $t2
| Parameters: |
|
|---|
Branch if Greater Than : Branch to statement at label if $t1 is greater than 16-bit immediate
| Parameters: |
|
|---|
Branch if Greater Than : Branch to statement at label if $t1 is greater than 32-bit immediate
| Parameters: |
|
|---|
Branch if Greater Than Unsigned: Branch to statement at label if $t1 is greater than $t2 (unsigned compare)
| Parameters: |
|
|---|
Branch if Greater Than Unsigned: Branch to statement at label if $t1 is greater than 16-bit immediate (unsigned compare)
| Parameters: |
|
|---|
Branch if Greater Than Unsigned: Branch to statement at label if $t1 is greater than 16-bit immediate (unsigned compare)
| Parameters: |
|
|---|
Branch if Less or Equal : Branch to statement at label if $t1 is less than or equal to $t2
| Parameters: |
|
|---|
Branch if Less or Equal : Branch to statement at label if $t1 is less than or equal to 16-bit immediate
| Parameters: |
|
|---|
Branch if Less or Equal : Branch to statement at label if $t1 is less than or equal to 32-bit immediate
| Parameters: |
|
|---|
Branch if Less or Equal Unsigned : Branch to statement at label if $t1 is less than or equal to $t2 (unsigned compare)
| Parameters: |
|
|---|
Branch if Less or Equal Unsigned : Branch to statement at label if $t1 is less than or equal to 16-bit immediate (unsigned compare)
| Parameters: |
|
|---|
Branch if Less or Equal Unsigned : Branch to statement at label if $t1 is less than or equal to 32-bit immediate (unsigned compare)
| Parameters: |
|
|---|
Branch if Less Than : Branch to statement at label if $t1 is less than $t2
| Parameters: |
|
|---|
Branch if Less Than : Branch to statement at label if $t1 is less than 16-bit immediate
| Parameters: |
|
|---|
Branch if Less Than : Branch to statement at label if $t1 is less than 32-bit immediate
| Parameters: |
|
|---|
Branch if Less Than Unsigned : Branch to statement at label if $t1 is less than $t2
| Parameters: |
|
|---|
Branch if Less Than Unsigned : Branch to statement at label if $t1 is less than 16-bit immediate
| Parameters: |
|
|---|
Branch if Less Than Unsigned : Branch to statement at label if $t1 is less than 32-bit immediate
| Parameters: |
|
|---|
Branch if Not Equal : Branch to statement at label if $t1 is not equal to 16-bit immediate
| Parameters: |
|
|---|
Branch if Not Equal : Branch to statement at label if $t1 is not equal to 32-bit immediate
| Parameters: |
|
|---|
Branch if Not Equal Zero : Branch to statement at label if $t1 is not equal to zero
| Parameters: |
|
|---|
DIVision : Set $t1 to ($t2 divided by $t3, integer division)
| Parameters: |
|
|---|
DIVision : Set $t1 to ($t2 divided by 16-bit immediate, integer division)
| Parameters: |
|
|---|
DIVision : Set $t1 to ($t2 divided by 32-bit immediate, integer division)
| Parameters: |
|
|---|
DIVision Unsigned : Set $t1 to ($t2 divided by $t3, unsigned integer division)
| Parameters: |
|
|---|
DIVision Unsigned : Set $t1 to ($t2 divided by 16-bit immediate, unsigned integer division)
| Parameters: |
|
|---|
DIVision Unsigned : Set $t1 to ($t2 divided by 32-bit immediate, unsigned integer division)
| Parameters: |
|
|---|
Load floating point Double precision : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load floating point Double precision : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load floating point Double precision : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load floating point Double precision : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load floating point Double precision : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load floating point Double precision : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load floating point Double precision : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
)Load floating point Double precision : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load floating point Single precision : Set $f1 to 32-bit value at effective memory word address
| Parameters: |
|
|---|
Load floating point Single precision : Set $f1 to 32-bit value at effective memory word address
| Parameters: |
|
|---|
Load floating point Single precision : Set $f1 to 32-bit value at effective memory word address
| Parameters: |
|
|---|
Load floating point Single precision : Set $f1 to 32-bit value at effective memory word address
| Parameters: |
|
|---|
Load floating point Single precision : Set $f1 to 32-bit value at effective memory word address
| Parameters: |
|
|---|
Load floating point Single precision : Set $f1 to 32-bit value at effective memory word address
| Parameters: |
|
|---|
Load floating point Single precision : Set $f1 to 32-bit value at effective memory word address
| Parameters: |
|
|---|
)Load floating point Single precision : Set $f1 to 32-bit value at effective memory word address
| Parameters: |
|
|---|
Load Address : Set $t1 to contents of $t2
| Parameters: |
|
|---|
Load Address : Set $t1 to 16-bit immediate (sign-extended)
| Parameters: |
|
|---|
Load Address : Set $t1 to 16-bit immediate (zero-extended)
| Parameters: |
|
|---|
Load Address : Set $t1 to sum (of $t2 and 16-bit immediate)
| Parameters: |
|
|---|
Load Address : Set $t1 to 32-bit immediate
| Parameters: |
|
|---|
Load Address : Set $t1 to sum (of $t2 and 32-bit immediate)
| Parameters: |
|
|---|
Load Address : Set $t1 to label’s address
| Parameters: |
|
|---|
Load Address : Set $t1 to sum (of $t2 and label’s address)
| Parameters: |
|
|---|
Load Address : Set $t1 to sum (of label’s address and 32-bit immediate)
| Parameters: |
|
|---|
Load Address : Set $t1 to sum (of label’s address, 32-bit immediate, and $t2)
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
)Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte address
| Parameters: |
|
|---|
Load Doubleword : Set $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Load Doubleword : Set $t1 and the next register to the 64 bits starting at effective memory byte address
| Parameters: |
|
|---|
Load Doubleword : Set $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Load Doubleword : Set $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Load Doubleword : Set $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Load Doubleword : Set $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Load Doubleword : Set $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Load Doubleword : Set $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Load Doubleword Coprocessor 1 : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load Doubleword Coprocessor 1 : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load Doubleword Coprocessor 1 : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load Doubleword Coprocessor 1 : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load Doubleword Coprocessor 1 : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load Doubleword Coprocessor 1 : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load Doubleword Coprocessor 1 : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
2)Load Doubleword Coprocessor 1 : Set $f2 and $f3 register pair to 64-bit value at effective memory doubleword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword : Set $t1 to sign-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
)Load Halfword Unsigned : Set $t1 to zero-extended 16-bit value from effective memory halfword address
| Parameters: |
|
|---|
Load Immediate : Set $t1 to 16-bit immediate (sign-extended)
| Parameters: |
|
|---|
Load Immediate : Set $t1 to unsigned 16-bit immediate (zero-extended)
| Parameters: |
|
|---|
Load Immediate : Set $t1 to 32-bit immediate
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Linked : Paired with Store Conditional (sc) to perform atomic read-modify-write. Treated as equivalent to Load Word (lw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of memory word at label’s address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word : Set $t1 to contents of effective memory word address
| Parameters: |
|
|---|
Load Word Coprocessor 1 : Set $f1 to 32-bit value from effective memory word address
| Parameters: |
|
|---|
Load Word Coprocessor 1 : Set $f1 to 32-bit value from effective memory word address
| Parameters: |
|
|---|
Load Word Coprocessor 1 : Set $f1 to 32-bit value from effective memory word address
| Parameters: |
|
|---|
Load Word Coprocessor 1 : Set $f1 to 32-bit value from effective memory word address
| Parameters: |
|
|---|
Load Word Coprocessor 1 : Set $f1 to 32-bit value from effective memory word address
| Parameters: |
|
|---|
Load Word Coprocessor 1 : Set $f1 to 32-bit value from effective memory word address
| Parameters: |
|
|---|
Load Word Coprocessor 1 : Set $f1 to 32-bit value from effective memory word address
| Parameters: |
|
|---|
2)Load Word Coprocessor 1 : Set $f1 to 32-bit value from effective memory word address
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
)Load Word Left : Load from 1 to 4 bytes left-justified into $t1, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
)Load Word Right : Load from 1 to 4 bytes right-justified into $t1, starting with effective memory byte address and continuing through the high-order byte of its word
| Parameters: |
|
|---|
Move From Coprocessor 1 Double : Set $t1 to contents of $f2, set next higher register from $t1 to contents of next higher register from $f2
| Parameters: |
|
|---|
MOVE : Set $t1 to contents of $t2
| Parameters: |
|
|---|
Move To Coprocessor 1 Double : Set $f2 to contents of $t1, set next higher register from $f2 to contents of next higher register from $t1
| Parameters: |
|
|---|
MULtiplication : Set HI to high-order 32 bits, LO and $t1 to low-order 32 bits of the product of $t2 and 16-bit signed immediate (use mfhi to access HI, mflo to access LO)
| Parameters: |
|
|---|
MULtiplication : Set HI to high-order 32 bits, LO and $t1 to low-order 32 bits of the product of $t2 and 32-bit immediate (use mfhi to access HI, mflo to access LO)
| Parameters: |
|
|---|
MULtiplication with Overflow : Set $t1 to low-order 32 bits of the product of $t2 and $t3
| Parameters: |
|
|---|
MULtiplication with Overflow : Set $t1 to low-order 32 bits of the product of $t2 and signed 16-bit immediate
| Parameters: |
|
|---|
MULtiplication with Overflow : Set $t1 to low-order 32 bits of the product of $t2 and 32-bit immediate
| Parameters: |
|
|---|
MULtiplication with Overflow Unsigned : Set $t1 to low-order 32 bits of the product of $t2 and $t3
| Parameters: |
|
|---|
MULtiplication with Overflow Unsigned : Set $t1 to low-order 32 bits of the product of $t2 and signed 16-bit immediate
| Parameters: |
|
|---|
MULtiplication with Overflow Unsigned : Set $t1 to low-order 32 bits of the product of $t2 and 32-bit immediate
| Parameters: |
|
|---|
MULtiplication Unsigned : Set HI to high-order 32 bits, LO and $t1 to low-order 32 bits of ($t2 multiplied by $t3, unsigned multiplication)
| Parameters: |
|
|---|
MULtiplication Unsigned : Set HI to high-order 32 bits, LO and $t1 to low-order 32 bits of ($t2 multiplied by 16-bit immediate, unsigned multiplication)
| Parameters: |
|
|---|
MULtiplication Unsigned : Set HI to high-order 32 bits, LO and $t1 to low-order 32 bits of ($t2 multiplied by 32-bit immediate, unsigned multiplication)
| Parameters: |
|
|---|
NEGate : Set $t1 to negation of $t2
| Parameters: |
|
|---|
NEGate Unsigned : Set $t1 to negation of $t2, no overflow
| Parameters: |
|
|---|
Bitwise NOT (bit inversion)
| Parameters: |
|
|---|
OR : set $t1 to ($t2 bitwise-OR 16-bit unsigned immediate)
| Parameters: |
|
|---|
OR : set $t1 to ($t1 bitwise-OR 16-bit unsigned immediate)
| Parameters: |
|
|---|
OR Immediate : set $t1 to ($t2 bitwise-OR 32-bit immediate)
| Parameters: |
|
|---|
OR Immediate : set $t1 to ($t1 bitwise-OR 16-bit unsigned immediate)
| Parameters: |
|
|---|
OR Immediate : set $t1 to ($t1 bitwise-OR 32-bit immediate)
| Parameters: |
|
|---|
REMainder : Set $t1 to (remainder of $t2 divided by $t3)
| Parameters: |
|
|---|
REMainder : Set $t1 to (remainder of $t2 divided by 16-bit immediate)
| Parameters: |
|
|---|
REMainder : Set $t1 to (remainder of $t2 divided by 32-bit immediate)
| Parameters: |
|
|---|
REMainder : Set $t1 to (remainder of $t2 divided by $t3, unsigned division)
| Parameters: |
|
|---|
REMainder : Set $t1 to (remainder of $t2 divided by 16-bit immediate, unsigned division)
| Parameters: |
|
|---|
REMainder : Set $t1 to (remainder of $t2 divided by 32-bit immediate, unsigned division)
| Parameters: |
|
|---|
ROtate Left : Set $t1 to ($t2 rotated left by number of bit positions specified in $t3)
| Parameters: |
|
|---|
ROtate Left : Set $t1 to ($t2 rotated left by number of bit positions specified in 5-bit immediate)
| Parameters: |
|
|---|
ROtate Right : Set $t1 to ($t2 rotated right by number of bit positions specified in $t3)
| Parameters: |
|
|---|
ROtate Right : Set $t1 to ($t2 rotated right by number of bit positions specified in 5-bit immediate)
| Parameters: |
|
|---|
Store floating point Double precision : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store floating point Double precision : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store floating point Double precision : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store floating point Double precision : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store floating point Double precision : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store floating point Double precision : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store floating point Double precision : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
)Store floating point Double precision : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store floating point Single precision : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store floating point Single precision : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store floating point Single precision : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store floating point Single precision : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store floating point Single precision : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store floating point Single precision : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store floating point Single precision : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
)Store floating point Single precision : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte address
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Conditional : Paired with Load Linked (ll) to perform atomic read-modify-write. Treated as equivalent to Store Word (sw) because MARS does not simulate multiple processors.
| Parameters: |
|
|---|
Store Doubleword : Store contents of $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Store Doubleword : Store contents of $t1 and the next register to the 64 bits starting at effective memory byte address
| Parameters: |
|
|---|
Store Doubleword : Store contents of $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Store Doubleword : Store contents of $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Store Doubleword : Store contents of $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Store Doubleword : Store contents of $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Store Doubleword : Store contents of $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Store Doubleword : Store contents of $t1 and the next register to the 64 bits starting at effective memory word address
| Parameters: |
|
|---|
Store Doubleword Coprocessor 1 : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store Doubleword Coprocessor 1 : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store Doubleword Coprocessor 1 : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store Doubleword Coprocessor 1 : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store Doubleword Coprocessor 1 : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store Doubleword Coprocessor 1 : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Store Doubleword Coprocessor 1 : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
2)Store Doubleword Coprocessor 1 : Store 64 bits from $f2 and $f3 register pair to effective memory doubleword address
| Parameters: |
|
|---|
Set EQual : if $t2 equal to $t3 then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set EQual : if $t2 equal to 16-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set EQual : if $t2 equal to 32-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater or Equal : if $t2 greater or equal to $t3 then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater or Equal : if $t2 greater or equal to 16-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater or Equal : if $t2 greater or equal to 32-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater or Equal Unsigned : if $t2 greater or equal to $t3 (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater or Equal Unsigned : if $t2 greater or equal to 16-bit immediate (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater or Equal Unsigned : if $t2 greater or equal to 32-bit immediate (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater Than : if $t2 greater than $t3 then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater Than : if $t2 greater than 16-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater Than : if $t2 greater than 32-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater Than Unsigned : if $t2 greater than $t3 (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater Than Unsigned : if $t2 greater than 16-bit immediate (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Greater Than Unsigned : if $t2 greater than 32-bit immediate (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address
| Parameters: |
|
|---|
Set Less or Equal : if $t2 less or equal to $t3 then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Less or Equal : if $t2 less or equal to 16-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Less or Equal : if $t2 less or equal to 32-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Less or Equal Unsigned: if $t2 less or equal to $t3 (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Less or Equal Unsigned: if $t2 less or equal to 16-bit immediate (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Less or Equal Unsigned: if $t2 less or equal to 32-bit immediate (unsigned compare) then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Not Equal : if $t2 not equal to $t3 then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Not Equal : if $t2 not equal to 16-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
Set Not Equal : if $t2 not equal to 32-bit immediate then set $t1 to 1 else 0
| Parameters: |
|
|---|
SUBtraction : set $t1 to ($t2 minus 16-bit immediate)
| Parameters: |
|
|---|
SUBtraction : set $t1 to ($t2 minus 32-bit immediate)
| Parameters: |
|
|---|
SUBtraction Immediate : set $t1 to ($t2 minus 16-bit immediate)
| Parameters: |
|
|---|
SUBtraction Immediate : set $t1 to ($t2 minus 32-bit immediate)
| Parameters: |
|
|---|
SUBtraction Immediate Unsigned : set $t1 to ($t2 minus 32-bit immediate), no overflow
| Parameters: |
|
|---|
SUBtraction Unsigned : set $t1 to ($t2 minus 32-bit immediate), no overflow
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into memory word at label’s address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word : Store $t1 contents into effective memory word address
| Parameters: |
|
|---|
Store Word Coprocessor 1 : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store Word Coprocessor 1 : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store Word Coprocessor 1 : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store Word Coprocessor 1 : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store Word Coprocessor 1 : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store Word Coprocessor 1 : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store Word Coprocessor 1 : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
2)Store Word Coprocessor 1 : Store 32-bit value from $f1 to effective memory word address
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
)Store Word Left : Store high-order 1 to 4 bytes of $t1 into memory, starting with effective memory byte address and continuing through the low-order byte of its word
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
)Store Word Right : Store low-order 1 to 4 bytes of $t1 into memory, starting with high-order byte of word containing effective memory byte address and continuing through that byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, sign-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, sign-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, sign-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, sign-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, sign-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, sign-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, sign-extended, starting at effective memory byte address
| Parameters: |
|
|---|
)Unaligned Load Halfword : Set $t1 to the 16 bits, sign-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, zero-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, zero-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, zero-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, zero-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, zero-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, zero-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Halfword : Set $t1 to the 16 bits, zero-extended, starting at effective memory byte address
| Parameters: |
|
|---|
2)Unaligned Load Halfword : Set $t1 to the 16 bits, zero-extended, starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Word : Set $t1 to the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Word : Set $t1 to the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Word : Set $t1 to the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Word : Set $t1 to the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Word : Set $t1 to the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Word : Set $t1 to the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Load Word : Set $t1 to the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
)Unaligned Load Word : Set $t1 to the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Halfword: Store low-order halfword $t1 contents into the 16 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Halfword: Store low-order halfword $t1 contents into the 16 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Halfword: Store low-order halfword $t1 contents into the 16 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Halfword: Store low-order halfword $t1 contents into the 16 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Halfword: Store low-order halfword $t1 contents into the 16 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Halfword: Store low-order halfword $t1 contents into the 16 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Halfword: Store low-order halfword $t1 contents into the 16 bits starting at effective memory byte address
| Parameters: |
|
|---|
)Unaligned Store Halfword: Store low-order halfword $t1 contents into the 16 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Word : Store $t1 contents into the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Word : Store $t1 contents into the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Word : Store $t1 contents into the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Word : Store $t1 contents into the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Word : Store $t1 contents into the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Word : Store $t1 contents into the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
Unaligned Store Word : Store $t1 contents into the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
)Unaligned Store Word : Store $t1 contents into the 32 bits starting at effective memory byte address
| Parameters: |
|
|---|
XOR : set $t1 to ($t2 bitwise-exclusive-OR 16-bit unsigned immediate)
| Parameters: |
|
|---|
XOR : set $t1 to ($t1 bitwise-exclusive-OR 16-bit unsigned immediate)
| Parameters: |
|
|---|
XOR Immediate : set $t1 to ($t2 bitwise-exclusive-OR 32-bit immediate)
| Parameters: |
|
|---|
XOR Immediate : set $t1 to ($t1 bitwise-exclusive-OR 16-bit unsigned immediate)
| Parameters: |
|
|---|
XOR Immediate : set $t1 to ($t1 bitwise-exclusive-OR 32-bit immediate)
| Parameters: |
|
|---|


{% extends "base.html" %} {% block content %} {% include "partials/header.html" %}
This will also delete all books within this category.


Discover how Linked Data Fragments enable Web-scale querying of Linked Data.
Enter a basic graph pattern query below and see how your browser solves it using only Basic Linked Data Fragments.
Discover how Linked Data Fragments enable Web-scale querying of Linked Data.


The communication between the widgets is done via configuration objects and a set of methods that all widgets implement. The widgets can join a configuration transmitter to send or get configuration updates. The settings and filter widget below join a hash configration that serializes the configuration state into the hash/anchor part of the URL. Alternatively, it is possible to just click on links with anchor references to update configrations, e.g.:
The filter widget below shows the selected settings:


Hi! My name is Matt Clutts. I am an aspiring web developer residing in Raleigh, North Carolina. Rewardingly enough, I have an unwavering passion for web development that is liken to a child's keen interest for Legos. I jump at the opportunity to take a graphic idea or vision and transform it into something tangible, innovative, unique, and useful.
At the fundamental level, I am a dynamic individual with an appetite for acquiring knowledge, solving problems, and accepting challenges. Due to these facets, I accept projects enthusiastically and am motivated by my own competitive nature and work ethic to excel in meeting the expectations I've set for myself and by others.
Outside of the office, my energetic traits are channeled into soccer, hiking, music, and my dog Petey.
Feel free to email me to if you like what you see and would like to work together or to just say hello!


HTML is a markup language for describing web documents (web pages). HTML stands for Hyper Text Markup Language A markup language is a set of markup tags HTML documents are described by HTML tags Each HTML tag describes different document content
<!DOCTYPE html>   <title>Page Title</title>
My First Heading

My first paragraph.

The DOCTYPE declaration defines the document type to be HTML The text between  and  describes an HTML document The text between  and  provides information about the document The textbetween <title> and </title> provides a title for the document The text between  and  describes the visible page content The text between
 and
 describes a heading The text between
 and
 describes a paragraph Using this description, a web browser can display a document with a heading and a paragraph.
HTML tags are keywords (tag names) surrounded by angle brackets:
<tagname>content</tagname>HTML tags normally come in pairs like

 and
The first tag in a pair is the start tag, the second tag is the end tag The end tag is written like the start tag, but with a slash before the tag name
HTML headings are defined with the
 to
 tags: Example
This is a heading

This is a heading

This is a heading

HTML headings are defined with the
 to
 tags: Example
This is a heading

This is a heading

This is a heading


Rockets seek royal revenge
by Wayne MooreThe Kelowna Rockets look to settle the score when they host the Victoria Royals tonight at Prospera Place.
Two weeks ago, the Royals took advantage of Rocket mistakes in a 6-3 victory. They scored in bunches that night, scoring three times on their first six shots and three more on their last six.
The Rockets come into the game a single point up on Victoria and two behind Vancouver as the teams battle for second, third and fourth in the BC Division.
Victoria comes in riding a four-game winning streak, while the Rockets snapped a four-game losing skid, beating Kamloops last Saturday.
"Anytime you face a B.C. Division team those are huge games for us and for the two points," said forward Alex Swetlikoff.
"I think we need to keep building off of last game said. We're the best when we stay out of the penalty box and are playing teams five on five. When we get our forecheck going and have a good neutral zone, I think we're successful."
Swetlikoff has been enjoying his best stretch as a Rockets of late, scoring goals in four of his last six games.
"I've been a little more hungrier, I've been shooting more and going to the net. I think I've been more physical and that's gotten me into the game more and made me better prepared."
The Rockets hit the road Thursday morning for weekend games in Seattle and Tri-City.


akka.stream
INTERNAL API As discussed in https://github.com/akka/akka/issues/16613
Generator of sequentially numbered actor names. Pulled out from HTTP internals, most often used used by streams which materialize actors directly
INTERNAL API
INTERNAL API As discussed in https://github.com/akka/akka/issues/16613
Generator of sequentially numbered actor names. Pulled out from HTTP internals, most often used used by streams which materialize actors directly


(Optional) Comma-separated list of environments to launch the agent with. If set, will not allow jobs to launch with this agent profile unless they're in one of the specified environments.
Job resources to request for each agent of this type.
Optional settings to bootstrap the agent with additional files and configuration not available on the host executor.


| 1 |
Öncü_2018 |
An evaluation of the effectiveness of nursing students' hand hygiene compliance: A cross-sectional study |
Öncü, Emine; Vayısoğlu, Sümbüle Köksoy; Lafcı, Diğdem; Yıldız, Ebru |
2018 |
2018-06-30 |
PMC |
N |
PMC7115509 |
29604605.0 |
10.1016/j.nedt.2018.02.027 |
cmaaa5j6 |
0.816421 |
|
Cruz_2016, O’Donoghue_2016 |
| 2 |
Gerald_2011 |
Redesigning a large school-based clinical trial in response to changes in community practice |
Gerald, Lynn B; Gerald, Joe K; McClure, Leslie A; Harrington, Kathy; Erwin, Sue; Bailey, William C |
2011 |
2011-06-23 |
COMM-USE |
N |
PMC3145214 |
21730079.0 |
10.1177/1740774511403513 |
1zzyfmkb |
0.796799 |
|
|
| 3 |
Hassan_2018 |
Improving knowledge and compliance with infection control Standard Precautions among undergraduate nursing students in Jordan |
Hassan, Zeinab M. |
2018 |
2018-03-31 |
PMC |
N |
PMC7115283 |
29102051.0 |
10.1016/j.ajic.2017.09.010 |
aqucr5wb |
0.684256 |
|
Cruz_2016 |
| 4 |
Kim_D_2019 |
Effects of Audio-Visual Stimulation on Hand Hygiene Compliance among Family and Non-Family Visitors of Pediatric Wards: A Quasi-Experimental Pre-post Intervention Study |
Kim, Duri; Lee, Ogcheol |
2019 |
2019-06-30 |
PMC |
N |
PMC7126652 |
30935725.0 |
10.1016/j.pedn.2019.03.017 |
r87am6k4 |
0.634228 |
|
O’Donoghue_2016, de_Amorim-Finzi_2010 |
| 5 |
O’Donoghue_2016 |
A quasi-experimental study to determine the effects of a multifaceted educational intervention on hand hygiene compliance in a radiography unit |
O’Donoghue, Margaret; Ng, Suk-Hing; Suen, Lorna KP; Boost, Maureen |
2016 |
2016-10-19 |
COMM-USE |
N |
PMC5070356 |
27777757.0 |
10.1186/s13756-016-0133-4 |
gu6ajv3r |
0.613470 |
|
Cruz_2016, Alshammari_2018, Yuan_2009 |
| 6 |
Cruz_2016 |
Predictors of hand hygiene practice among Saudi nursing students: A cross-sectional self-reported study |
Cruz, Jonas P.; Bashtawi, Meshrif A. |
2016 |
2016-08-31 |
PMC |
N |
PMC7102782 |
26707706.0 |
10.1016/j.jiph.2015.11.010 |
wr49giux |
0.609192 |
|
Alshammari_2018, Yuan_2009 |
| 7 |
Linam_2019 |
Focusing on Families and Visitors Reduces Healthcare Associated Respiratory Viral Infections in a Neonatal Intensive Care Unit |
Linam, W. Matthew; Marrero, Elizabeth M.; Honeycutt, Michele D.; Wisdom, Christy M.; Gaspar, Anna; Vijayan, Vini |
2019 |
2019-12-16 |
NONCOMM |
N |
PMC6946222 |
32010868.0 |
10.1097/pq9.0000000000000242 |
sxkr87bx |
0.596670 |
|
Islam_2014 |
| 8 |
Kim_H_2018 |
The usefulness of hand washing during field training to prevent acute respiratory illness in a military training facility |
Kim, Ho Seung; Ko, Ryoung Eun; Ji, Misuk; Lee, Ju-Hyung; Lee, Chang-Seop; Lee, Hyun |
2018 |
2018-07-27 |
NONCOMM |
N |
PMC6078659 |
30045292.0 |
10.1097/md.0000000000011594 |
xg1cnlot |
0.570479 |
|
|
| 9 |
de_Amorim-Finzi_2010 |
Rate of Compliance with Hand Hygiene by Dental Healthcare Personnel (DHCP) within a Dentistry Healthcare First Aid Facility |
de Amorim-Finzi, Marcília Batista; Cury, Mauro Vieira Cezar; Costa, Cláudio Rodrigues R.; dos Santos, Angelis Costa; de Melo, Geraldo Batista |
2010 |
2010-07-23 |
PMC |
N |
PMC2897854 |
20613909.0 |
|
qfck720q |
0.538944 |
|
Cruz_2016, Alshammari_2018, O’Donoghue_2016 |
| 10 |
Trampuz_2004 |
Hand Hygiene: A Frequently Missed Lifesaving Opportunity During Patient Care |
Trampuz, Andrej; Widmer, Andreas F. |
2004 |
2004-01-31 |
PMC |
N |
PMC7094481 |
14708954.0 |
10.4065/79.1.109 |
lbmxfhiv |
0.525210 |
Carling_2016 |
Yuan_2009, Lin_Huang_2014, Cruz_2016 |
| 11 |
Bloomfield_2007 |
The effectiveness of hand hygiene procedures in reducing the risks of infections in home and community settings including handwashing and alcohol-based hand sanitizers |
Bloomfield, Sally F.; Aiello, Allison E.; Cookson, Barry; O'Boyle, Carol; Larson, Elaine L. |
2007 |
2007-12-31 |
PMC |
N |
PMC7115270 |
|
10.1016/j.ajic.2007.07.001 |
lyewg2c9 |
0.464461 |
|
Alshammari_2018, Lin_Huang_2014, Gamage_2005 |
| 12 |
Ling_2012 |
Impact of a hospital-wide hand hygiene promotion strategy on healthcare-associated infections |
Ling, Moi Lin; How, Kue Bien |
2012 |
2012-03-23 |
COMM-USE |
N |
PMC3436662 |
22958911.0 |
10.1186/2047-2994-1-13 |
khqvezmu |
0.459401 |
Esswein_2004 |
Alshammari_2018, Cruz_2016, Yuan_2009 |
| 13 |
Lee_T_2005 |
Selected nonvaccine interventions to prevent infectious acute respiratory disease |
Lee, Terrence; Jordan, Nikki N.; Sanchez, Jose L.; Gaydos, Joel C. |
2005 |
2005-04-30 |
PMC |
N |
PMC7135187 |
15766621.0 |
10.1016/j.amepre.2004.12.010 |
o9ni4vq7 |
0.430229 |
|
|
| 14 |
Alfahan_2016 |
In the era of corona virus: health care professionals’ knowledge, attitudes, and practice of hand hygiene in Saudi primary care centers: a cross-sectional study |
Alfahan, Ali; Alhabib, Samia; Abdulmajeed, Imad; Rahman, Saeed; Bamuhair, Samira |
2016 |
2016-09-07 |
NONCOMM |
N |
PMC5016750 |
27609728.0 |
10.3402/jchimp.v6.32151 |
h32isbwz |
0.397960 |
|
Cruz_2016, Alshammari_2018 |
| 15 |
Allegranzi_2009 |
Religion and culture: Potential undercurrents influencing hand hygiene promotion in health care |
Allegranzi, Benedetta; Memish, Ziad A.; Donaldson, Liam; Pittet, Didier |
2009 |
2009-02-28 |
PMC |
N |
PMC7115273 |
18834738.0 |
10.1016/j.ajic.2008.01.014 |
c69vfs8q |
0.388144 |
Esswein_2004 |
Yuan_2009, Cruz_2016, Alshammari_2018 |
| 16 |
Kwok_2015 |
Face touching: A frequent habit that has implications for hand hygiene |
Kwok, Yen Lee Angela; Gralton, Jan; McLaws, Mary-Louise |
2015 |
2015-02-01 |
PMC |
N |
PMC7115329 |
25637115.0 |
10.1016/j.ajic.2014.10.015 |
tuositq1 |
0.355543 |
|
Cruz_2016 |
| 17 |
Al-Tawfiq_2019 |
Infection control influence of Middle East respiratory syndrome coronavirus: A hospital-based analysis |
Al-Tawfiq, Jaffar A.; Abdrabalnabi, Rana; Taher, Alla; Mathew, Shantymole; Rahman, Kamal Abdul |
2019 |
2019-04-30 |
PMC |
N |
PMC7115328 |
30502108.0 |
10.1016/j.ajic.2018.09.015 |
mcmazu1v |
0.332783 |
Trampuz_2004 |
|
| 18 |
Yuan_2009 |
Perceptions of hand hygiene practices in China |
Yuan, C.T.; Dembry, L.M.; Higa, B.; Fu, M.; Wang, H.; Bradley, E.H. |
2009 |
2009-02-28 |
PMC |
N |
PMC7132447 |
19013685.0 |
10.1016/j.jhin.2008.09.017 |
4g3x5dje |
0.330940 |
|
Cruz_2016, Alshammari_2018, Trampuz_2004 |
| 19 |
Esswein_2004 |
Environmental and Occupational Health Response to SARS, Taiwan, 2003 |
Esswein, Eric J.; Kiefer, Max; Wallingford, Ken; Burr, Greg; Lee, Lukas Jyhun-Hsiarn; Wang, Jung-Der; Wang, Shun Chih; Su, Ih-Jen |
2004 |
2004-07-23 |
PMC |
N |
PMC3323342 |
15324536.0 |
10.3201/eid1007.030728 |
3qyralpi |
0.326978 |
|
|
| 20 |
Alshammari_2018 |
Comparison of Perceived and Observed Hand Hygiene Compliance in Healthcare Workers in MERS-CoV Endemic Regions |
Alshammari, Modhi; Reynolds, Kelly A.; Verhougstraete, Marc; O’Rourke, Mary Kay |
2018 |
2018-10-07 |
COMM-USE |
N |
PMC6315729 |
30301272.0 |
10.3390/healthcare6040122 |
e64k5nl8 |
0.319429 |
|
Cruz_2016, Yuan_2009, Alfahan_2016, Gamage_2005 |
| 21 |
Godoy_2012 |
Effectiveness of hand hygiene and provision of information in preventing influenza cases requiring hospitalization |
Godoy, Pere; Castilla, Jesús; Delgado-Rodríguez, Miguel; Martín, Vicente; Soldevila, Núria; Alonso, Jordi; Astray, Jenaro; Baricot, Maretva; Cantón, Rafael; Castro, Ady; González-Candelas, Fernando; Mayoral, José María; Quintana, José María; Pumarola, Tomás; Tamames, Sonia; Domínguez, Angela |
2012 |
2012-06-30 |
PMC |
N |
PMC7119305 |
22548868.0 |
10.1016/j.ypmed.2012.04.009 |
706bf8qr |
0.314169 |
Liu_X_2014 |
Alshammari_2018 |


This is a team of talented people with big ideas and creative minds. They develop exclusive designs, unique, easy and clear functionality of the products. They are a team of young professionals who are always open to new knowledge.George Brown
adamparr.com


?L
Catasœs
Diciembre
2003
THE
NEW
YORK
BOTANICƒ.
GARDEN
BXPLORATION
OF
CUBA
Province
of
Pinar
del
Rio
~
arroyo
del
Sumidero
r
cu-aX£-j-^u^
f
crz/z.
No.
/3
i&4r.
2‡&.
j.
A.
Shafer
’
COLLECTORS
AUGUÈ
7
a
BROTH
E
R
LEON
’
*UOUST
7f
9,
1912
IfcDMT–S
1604985
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Choose Action Channel step 4 of 7
Showing Channels that provide at least one Action.
@for(channel <- channels) {
@{counter %= 6}
@if(channel.getActions().size() > 0){
@channel.getName()
@{counter += 1}
}
}


14. Stack
The stack functions manipulate a simple LIFO stack of pointers to objects but the underlying array will grow and shrink as storage requirements change.
14.1.
The stack_init function
Synopsis
#include <mba/stack.h>
int stack_init(struct stack *s, unsigned int max_size, struct allocator *al);
Description
The stack_init function initializes the stack s and saving a pointer to the allocator(3m) al which will be used to allocate memory for susequent stack operations. The stack will accept no more than max data pointers. If max is 0, INT_MAX elements may be pushed onto the stack.
Returns
The stack_init function returns -1 if s is a null pointer. Otherwise 0 is returned.
The stack_deinit function
Synopsis
#include <mba/stack.h>
int stack_deinit(struct stack *s, del_fn data_del, void *context)
Description
The stack_deinit function deinitializes the stack s. If the data_del function is not NULL, it will be called with the context parameter and each element on the stack.
Returns
The stack_deinit function returns 0 if the stack was successfully deinitialized or -1 if the data_del function returned anything other than 0 or if an error occured attempting to free the memory backing the stack.
The stack_new function
Synopsis
#include <mba/stack.h>
struct stack *stack_new(unsigned int max_size, struct allocator *al);
Description
Create a new stack(3) object that will accept no more than max_size data pointers. If max_size is 0, the stack will accept at most INT_MAX elements.
Returns
The stack_new function returns a new stack object or NULL of memory could not be allocated in which case errno will be set to ENOMEM.
The stack_del function
Synopsis
#include <mba/stack.h>
int stack_del(struct stack *s, del_fn data_del, void *context);
Description
The stack_del function deletes the stack object s. If the data_del function is not NULL, it will be called with each remaining element before deallocating the stack s itself.
The stack_clear function
Synopsis
#include <mba/stack.h>
int stack_clear(struct stack *s, del_fn data_del, void *context)
Description
The stack_clear function will remove all elements on the stack. If the data_del function is not NULL it will be called with each remaining element.
The stack_clean function
Synopsis
#include <mba/stack.h>
int stack_clean(struct stack *s)
Description
The stack_clean function reallocates the array backing the stack to be exactly the number of elements necessary. A stack(3m) will automatically shrink at an appropriate point but this function might be called by an allocator(3m) reclaim_fn function.
14.2. Stack functions
The stack_push function
Synopsis
#include <mba/stack.h>
int stack_push(struct stack *s, void *data);
Description
The stack_push function pushes the element data onto the stack identified by s;
Returns
The stack_push function returns -1 and sets errno to an appropriate value if the operation failed or 0 if the data pointer was successfully pushed onto the stack (e.g. ERANGE if the stack is full).
The stack_pop function
Synopsis
#include <mba/stack.h>
void *stack_pop(struct stack *s);
Description
The stack_pop function removes the last element pushed onto the stack s.
Returns
The stack_pop function returns the data pointer popped off the stack.
The stack_is_empty function
Synopsis
#include <mba/stack.h>
int stack_is_empty(const struct stack *s);
Description
Returns non-zero if the stack s has no elements and 0 otherwise.
The stack_size function
Synopsis
#include <mba/stack.h>
unsigned int stack_size(const struct stack *s);
Description
The stack_size function returns the number of elements currently on the stack.
The stack_iterate function
Synopsis
#include <mba/stack.h>
void stack_iterate(void *s, iter_t *iter);
Description
Enumerate each element on the stack. Call stack_iterate to initialize the iter object to point to the bottom of the stack (the first element pushed onto the stack) and call stack_next to retrieve each data pointer. When the top of the stack has been reached, stack_next will return NULL.
The stack_next function
Synopsis
#include <mba/stack.h>
void *stack_next(void *s, iter_t *iter);
Returns
The stack_next function returns the next data pointer on the stack or NULL if the top of the stack has been exceeded.
The stack_peek function
Synopsis
#include <mba/stack.h>
void *stack_peek(struct stack *s);
Description
The stack_peek function returns the element at the top of the stack s or NULL of the stack is empty. The data pointer is not removed.
Copyright 2002 Michael B. Allen <mba2000 ioplex.com>


| Contents | Previous Next |
The Human Evasion by Celia Green
Sane human beings are not interested in reality. This is clearly shown by the attitudes of both Christians and sceptics towards the origins of Christianity. Both factions are primarily concerned to attribute "human" emotions to its foundernice modest fair-minded ones or nasty perverted abnormal ones according to taste. Neither side pauses to consider whether the available documents are remotely adequate to support their interpretations.Now in fact the historical evidence is of such a kind that the question may reasonably be asked whether Jesus lived at all. None of the gospels can be dated much earlier than A.D. 57, and probably all the four synoptic gospels were written around the latter half of the first century A.D. There is every reason to suppose that the tradition had already been subject to many influences, some identifiable, some debatable. There is no reason to suppose that the writers of the Gospels were any more interested in facts than most sane people are. In fact the internal evidence clearly suggests that they had no inhibitions about modifying their text when they wished to make it support a particular point.
It is difficult to base any conclusions whatever on documents of this kind.
It is certainly impossible to see how they can be made to support statements of the kind sometimes made by Christiansthat they derive from the Gospels an overwhelming sense of the personality of Christ. Or, indeed, a statement such as this made by an intellectual Christian in a University environment:
The discrepancy between the depth and sanity and (let me add) shrewdness of His moral teaching and the rampant megalomania which must lie behind His theological teaching unless He is indeed God, has never been satisfactorily got over.[1]In fact. there is very little "moral teaching" in the Gospels, and what there is is not shrewd. It simply makes unreasonable demands, of the utmost generality, of a kind that any purveyor of mental health would recommend his patients to disregard.
As for the theological teaching of Jesus, we do not know what it was. There is quite insufficient evidence for supposing that he claimed to be God, though we know that Christians from the fourth century onwards liked to make this claim on his behalf.
Probably more credit should be given to St. Paul. He was clearly a sane personaware of the need to make a good impression on the neighbours. It may well be that the true reason for the survival of Christianity lies in his having adapted it into a form admirably compatible with sane psychology. Much confusion has been created by reading the Epistles of Paul as if they shed light on the interpretation of the Gospels.
Consider the doctrine of the Fatherhood of God. This is supposed to have been central to the thought of Jesus. In fact, by all accounts, he had a positive obsession about it. Christians claim that it shows him to have been a warm, family-centred man and no cold metaphysician. Non-Christians claim that it shows him to have a father-fixation, combined with homosexual tendencies which he sought to gratify by his dubious relationship with his disciples.
Now, on grounds of textual criticism, it can be shown that there is little evidence that Christ himself had any particular interest in the Father concepteven as a symbolstill less in the Father-Son combination which is so important to later claims of the divinity of Christ. Although Jesus is credited with using the term Father frequently in Matthew and John, this is not the case in Mark, the earliest of the Gospels.
In Mark, God is only spoken of as Father in the absolute sense, without qualification, in two passages, both of which are believed to be either editorial interpolations or editorially modified.... Moreover, the expression my Father is never found in Mark, and your Father is found only in xi. 25-26.[2]
In fact, it is virtually impossible to reach any firm conclusions about what Jesus understood by "God". Attempts have been made to reconstruct his idea of God from the Jewish tradition of the time, but there is no knowing what influence this actually had on his thought. Modern man may like to believe himself the child of his environment, and his ideas the inevitable consequence of sociological influence. However, a few people have been known to think, and we cannot be sure that Jesus was not one of them. (The fact that the religion originated by him became widely accepted is not, of course, evidence for this supposition, but against it. If, that is, he did in any sense originate the religion which became accepted.)
If he was, he would probably have been capable of using the current terminology and sayings of his time in a sense of his own. There is no need to suppose him moronically unintelligent. The use of parables would seem to imply that he understood the use of metaphor.
We are not, I think, justified in concluding anything about the attitudes or opinions of Jesus from the areas of omission in the Gospels. Obviously we have only a handful of his sayings. The tradition had had plenty of time, before A.D. 57, to select those sayings which were reasonably compatible with the developing tradition of the Church, and to suppress the rest. The fact that we have only metaphor rather than description or definition to help us decide what he meant by "God" or "The Kingdom of Heaven" may not mean that he was a simple, emotional person who never defined his terms. It may only mean that his metaphors were all of his thought that could survive the transition into the world-view of the early Church.
Having said what cannot be inferred from the existing records, we may settle down to speculation.
There is an interesting possibility that Christ was not only not paranoid, but that he was not sane at all, and that the expression "the Kingdom of Heaven" refers to a state of mind not likely to be had by sane people. Let us discuss some of his utterances in the light of this possibility.
Matthew 13: 45-46Again, the kingdom of heaven is like unto a merchant man, seeking goodly pearls; who, when he had found one pearl of great price, went and sold all that he had, and bought it.
Mark 8: 36-37
What shall it profit a man, if he shall gain the whole world, and loose his own soul? Or what shall a man give in exchange for his soul?
To suggest that one single thing could be worth more than everything else put together is, I feel sure, an immature attitude.
Matthew 7: 13-14Enter ye in at the strait gate: for wide is the gate, and broad is the way, that leadeth to destruction, and many there be which go in thereat: Because strait is the gate, and narrow is the way, which leadeth unto life, and few there be that find it.
This is scarcely democratic and I do not see what a modern Christian can make of it. But it is a realistic assessment of the number of people likely to take up single-mindedness at all seriously.
 This is the first and great commandment.
Matthew 7: 7
Ask, and it shall be given you; seek, and ye shall find; knock, and it shall be opened unto you.
Sane people are obviously not likely to qualify for anything on these terms.
They cannot want anything very much, or try to get anything very hard. They accept the first compensation that comes their way.
Luke 6: 24-26
But woe unto you that are rich! for ye have received your consolation.
Woe unto you that are full! for ye shall hunger. Woe unto you that laugh now! for ye shall mourn and weep.
Woe unto you, when all men shall speak well of you! for so did their fathers to the false prophets.
Does this really sound as though he was in favour of the jolly, well-compensated man-in-society?
Matthew 19: 21-23A rather more interesting reading becomes possible if it is supposed that "riches" means "compensations".Jesus said unto him, If thou wilt be perfect, go and sell that thou hast, and give to the poor, and thou shalt have treasure in heaven: and come and follow me.
But when the young man heard that saying, he went away sorrowful: for he had great possessions.
Then Jesus said unto his disciples, Verily I say unto you, That a rich man shall hardly enter into the kingdom of heaven.
Modern Christians hold that the thing to do is "obviously" to feed everybody in the world, and until we have done that, we needn't ask what anyone is to do with their life, anyway. The question is whether Christ would have agreed.Matthew 6: 31-33
Therefore take no thought, saying, What shall we eat? or, What shall we drink? or, Wherewithal shall we be clothed? (For after all these things do the Gentiles seek:) for your heavenly Father knoweth that ye have need of all these things. But seek ye first the kingdom of God, and his righteousness; and all these things shall be added unto you.
Luke 18: 16-17But Jesus called them unto him, and said, Suffer little children to come unto me, and forbid them not: for of such is the kingdom of God.
Verily I say unto you, Whosoever shall not receive the kingdom of God as a little child shall in no wise enter therein.
It has been suggested that what Christ found attractive about children was what sane people like about themtheir uncritical trust in the superior wisdom of adults, their plasticity, submissiveness, suggestibility, and vulnerability. However, children have other characteristics besides these.
They are excitable and like excitement. They are in a hurry; it seems to them that to do a thing now may be altogether different from doing it tomorrow.
They are easily bored. They ask questions. They want to grow up to be the first Emperor of Space.
In short, they seek intensity of experience. They do not have much experience of life and they may seek it clumsily. As they grow older and saner they learn not to seek it at all.
Matthew 12:25Modern enlightenment suggests that Christ was talking about the integration of the personality. The modern idea of integrating the personality is to accept all the bits of yourself on their own termsenjoy all your pleasures without imposing upon them any rigid formalism. But this may not have been exactly what Christ had in mind. For one thing, modern people regard integration as a function of maturitybut Christ seemed to think children in some way eligible.Every kingdom divided against itself is brought to desolation; and every city or house divided against itself shall not stand.
Matthew 6: 22-23This makes it tolerably clear that if he was talking about the integration of the personality, it was a single-minded sort of integration.The light of the body is the eye: if therefore thine eye be single, the whole body shall be full of light.  If therefore the light that is in thee be darkness, how great is that darkness!
Matthew 6: 24It has been suggested that "mammon" means crude, ambitious, materialistic commercialism. Perhaps it just means "society", or even "other people".No man can serve two masters: for either he will hate the one, and love the other; or else he will hold to the one, and despise the other. Ye cannot serve God and mammon.
Matthew 15: 9Would Jesus really have liked the idea that Christianity meant social conformity and lots of welfare work?But in vain do they worship me, teaching for doctrines the commandments of men.
John 5: 44
How can ye believe, which receive honour from one of another, and seek not the honour that cometh from God only?
Matthew 10: 35Not-sane people need not expect sane people to see eye to eye with them.For I am come to set a man at variance against his father, and the daughter against her mother, and the daughter-in-law against her mother-in-law.
Luke 8: 19-21Undemocratic.Then came to him his mother and his brethren, and could not come at him for the press. And it was told him by certain which said, Thy mother and thy brethren stand without, desiring to see thee. And he answered and said unto them, My mother and my brethren are these which hear the word of God, and do it.
Matthew 9: 16-17Perhaps this means "You cannot be sane and not-sane at the same time." But even supposing a sane person had a moment's excitement, would he not try to weld it into his ordinary world-viewto "integrate" it, as he would say?No man putteth a piece of new cloth unto an old garment, for that which is put in to fill it up taketh from the garment, and the rent is made worse.
Neither do men put new wine into old bottles: else the bottles break, and the wine runneth out, and the bottles perish: but they put new wine into new bottles, and both are preserved.
John 12: 25Does this sound like settling down happily within your finiteness?He that loveth his life shall lose it; and he that hateth his life in this world shall keep it unto life eternal.
Luke 12: 25-26
And which of you with taking thought can add to his stature one cubit? If ye then be not able to do that thing which is least, why take ye thought for the rest?
Luke 1: 37This could be a statement about the total uncertainty. For its philosophical status, see Chapter 9.For with God nothing shall be impossible.
John 10: 34A most unpopular piece of Christianity. Sane people do not want to be gods; they want to be ordinary-members-of-society-like-anybody-else.Jesus answered them, Is it not written in your law, I said, Ye are gods?
Mark 11: 25No sane person doubts the impossibility of moving mountains by will-power.For verily I say unto you, That whosoever shall say unto this mountain, Be thou removed, and be thou cast into the sea; and shall not doubt in his heart, but shall believe that those things which he saith shall come to pass; he shall have whatsoever he saith.
Philosophically, however, it cannot be shown to be impossible.
Matthew 13: 35This may sound megalomaniac. But there is no great difficulty in keeping secrets from sane people. The incredibility of the fact of existence retains the status of a closely-guarded secret in spite of its accessibility to inspection.I will utter things which have been kept secret from the foundation of the world.
Mark 13: 35-37Whatever this may mean, it certainly demands a psychological attitude which is improbable in the sane. Live as though you expected the unexpected? As though something might happen?Watch ye therefore: for ye know not when the master of the house cometh, at even, or at midnight, or at the cock-crowing, or in the morning: Lest coming suddenly he find you sleeping.

However, if Christ was trying to talk people out of their adherence to sanity, he made one fatal mistake. He said "Love your neighbour as yourself." No one who understands the human evasion could fail to realize that any statement which could be interpreted as an exhortation to pay attention to other people, even if among a great many injunctions to single-mindedness and unconditional desire, would be the only one remembered.
In fact, everyone does love their neighbour as themselves. They desire that he shall accept the second-best as they have done; that he, too, shall be made to realize his limitations and "come to terms with himself".
The other aspect of Christ's thought that has seized upon the popular imagination is, of course, the use of the Father-symbol. If Christ was not sane, he may have meant something peculiar by "Father", and not necessarily something very human. He may even have meant something like "the Outside" or "the origin of existence".
[1] C.S. Lewis, Miracles, Collins Fontana Paperback, 1947, p.113. [2] Charles Guignebert, Jesus, University Books, 1956, p.360.
| Contents | deoxy > thoughtcrime | Previous Next |


| LIN | NSN | Item Name | PBIC | Type | DND | OH Qty |
|---|---|---|---|---|---|---|
| PIN,HEADED,TRIGGER | APS | N | 4 | |||
| BAR,STABILIZER | APS | N | 1 | |||
| BRACKET,SHOCK MOUNT | APS | N | 2 | |||
| SHOCK ABSORBER,DIRECT ACTION | APS | N | 3 | |||
| YOKE AND SLINGER,TRANSFER | APS | N | 1 | |||
| YOKE,UNIVERSAL JOINT,VEHICULAR | APS | N | 1 | |||
| PARTS KIT,UNIVERSAL JOINT | APS | N | 1 | |||
| SHAFT,AXLE,AUTOMOTIVE | APS | N | 1 | |||
| TIE ROD END,STEERING | APS | N | 2 | |||
| STEERING WHEEL | APS | N | 1 | |||
| PARTS KIT,STEERING COLUMN | APS | N | 1 | |||
| ARM,CONTROL,VEHICULAR SUSPENSI | APS | N | 1 | |||
| ARM,CONTROL,VEHICULAR SUSPENSI | APS | N | 2 | |||
| CONTROL ASSEMBLY,PUSH-PULL | APS | N | 1 | |||
| PULLEY,GROOVE | APS | N | 1 | |||
| BEARING UNIT,BALL | APS | N | 2 | |||
| TUBE ASSEMBLY,METAL | APS | N | 1 | |||
| TUBE,BENT,METALLIC | APS | N | 1 | |||
| HOSE,NONMETALLIC | APS | N | 3 | |||
| TEE,TUBE | APS | N | 85 | |||
| SCREW,CAP,HEXAGON HEAD | APS | N | 33 | |||
| SCREW | APS | N | 200 | |||
| SCREW,CAP,HEXAGON HEAD | APS | N | 460 | |||
| SCREW,CAP,HEXAGON HEAD | APS | N | 2 | |||
| SCREW,CAP,HEXAGON HEAD | APS | N | 75 | |||
| SCREW,CAP,HEXAGON HEAD | APS | N | 2 | |||
| SETSCREW | APS | N | 8 | |||
| SCREW,CAP,SOCKET HEAD | APS | N | 4 | |||
| SCREW,CAP,HEXAGON HEAD | APS | N | 3 | |||
| BOLT,MACHINE | APS | N | 11 | |||
| BOLT,MACHINE | APS | N | 20 | |||
| STUD,SELF-LOCKING | APS | N | 6 | |||
| WASHER,FLAT | APS | N | 17 | |||
| NUT,SELF-LOCKING,HEXAGON | APS | N | 200 | |||
| NUT,PLAIN,HEXAGON | APS | N | 1 | |||
| WASHER,FLAT | APS | N | 1 | |||
| NUT,SELF-LOCKING,HEXAGON | APS | N | 2 | |||
| WASHER,LOCK | APS | N | 2 | |||
| NUT,PLAIN,HEXAGON | APS | N | 1 | |||
| PIN,HINGE | APS | N | 4 | |||
| GASKET | APS | N | 19 | |||
| BRACKET,ENGINE ACCESSORY | APS | N | 1 | |||
| SPRING,HELICAL,COMPRESSION | APS | N | 14 | |||
| POST,FENCE,METAL | APS | N | 777 | |||
| DRIVER,FENCE POST | APS | N | 1 | |||
| SWITCH,SENSITIVE | APS | N | 5 | |||
| CONNECTOR,PLUG,ELECTRICAL | APS | N | 1 | |||
| TERMINAL,LUG | APS | N | 2 | |||
| LIGHT EMITTING DIODE | APS | N | 28 | |||
| MOUNT,MACHINE GUN | APS | N | 7 | |||
| MOUNT,GUN | APS | N | 6 | |||
| PURGING KIT,FIRE CONTROL | APS | N | 2 | |||
| TRUCK,WRECKER | APS | N | 1 | |||
| TRUCK,CARGO | APS | Y | 1 | |||
| TRUCK,TANK | APS | N | 1 | |||
| TRUCK,UTILITY | APS | N | 2 | |||
| SHOP SET,GLASS CUTTING,VEHICLE | APS | N | 1 |


{% extends "base.html" %} {% load staticfiles i18n %} {% block title %} About Us {% endblock %} {% block content %}
We founded Your3D on the sole mission of streamlining the process of bringing your project from idea to reality. Finding the right service to bring your project to life is difficult, time-consuming, and costly. Not only that, but 3D printing can be complex and difficult to understand for beginners. So, we set out to bring the best service out there to you.
Answer a few questions about your budget, timetable, your project’s specifications, and we take care of the rest. For beginners, dive deeper into your project in our recommendation matrix to receive ideas for the materials and printing processes we think best for your project.
From there we give you the best providers that are matched specifically to you. Simply browse these great providers, choose the best fit, and we send you and your project’s information directly to them for a quote and manufacturing as fast as possible.
Simply tell us about your project and we'll take care of finding the best provider for you in seconds.
Are you a business looking to join our network? Great! We're looking to expand everyday. Follow the Business portal to get started.
More questions about our service or what we provide? We love to hear feedback from our users! Fill out our question/comment form below and we'll get back to you as soon as possible.
{# #}


This guide explains how to use latinum
with Relaxo.
Direct Serialization
Latinum is natively supported by Relaxo and as such can be used with Relaxo::Model easily.
require 'latinum'
require 'relaxo/model'
require 'relaxo/model/properties/latinum'
class Transaction
include Relaxo::Model
property :name
property :price, Attribute[Latinum::Resource]
end
db = Relaxo.connect('test')
db.create!
t = Transaction.create(db, price: Latinum::Resource.load("50 NZD"))
t.price
# => <Latinum::Resource "50.0 NZD">
# Save and reload from database server:
t.save
t = Transaction.fetch(db, t.id)
t.price
# => <Latinum::Resource "50.0 NZD">
It gets stored in the database like so:
{
"_id": "740f4728fc9a571d826688db2f004771",
"_rev": "1-45a29c63311cfa0d5a765707184b2b3b",
"type": "transaction",
"price": [
"50.0",
"NZD"
]
}


Writeup
Code snippets
AlphaCutOff_Vertex.glsl
//Attributes represent components of your vertex data
attribute highp vec3 vPos ;
attribute lowp vec2 vUV ;
//Varying specifies attribute data that will be used by the fragment shader
varying lowp vec2 v_UV;
//Uniforms are values that remain the same across each instance of the vertex shader in this draw call
uniform highp float _Time;
void main()
{
highp vec4 position = vec4(vPos,1.0);
{
//creating a rotation matrix. Done in shader for simplicity, better practice to pass via uniform.
mat4 rotationMatrix;
rotationMatrix[0][0] = cos(_Time);
rotationMatrix[0][1] = sin(_Time);
rotationMatrix[0][2] = 0.0 ;
rotationMatrix[0][3] = 0.0 ;
rotationMatrix[1][0] =-sin(_Time);
rotationMatrix[1][1] = cos(_Time);
rotationMatrix[1][2] = 0.0 ;
rotationMatrix[1][3] = 0.0 ;
rotationMatrix[2][0] = 0.0 ;
rotationMatrix[2][1] = 0.0 ;
rotationMatrix[2][2] = 1.0 ;
rotationMatrix[2][3] = 0.0 ;
rotationMatrix[3][0] = 0.0;
rotationMatrix[3][1] = 0.0;
rotationMatrix[3][2] = 0.0;
rotationMatrix[3][3] = 1.0;
//example vector * mat mul. generally you will see a mul against an MVP in the vertex shader
position = rotationMatrix*position;
}
gl_Position = position; //pass final position value to the gl
v_UV = vUV; //pass UV attribute to the fragment shader
}
AlphaCutOff_Fragment.glsl
precision mediump float; //specifies the byte size for float type. This is a unique requirement of WebGL
varying lowp vec2 v_UV; //attribute data passed to the fragment shader from the vertex shader
uniform sampler2D _Texture; //a sampler2D corresponds to a 2D texture
void main()
{
lowp vec4 rvalue = vec4(0);
{
rvalue = texture2D(_Texture, v_UV); //retreve RGBA from texel at position UV
//Destroy the fragment if the alpha channel is not 1 (completely opaque)
if (rvalue[3] < 1.0)
discard;
}
gl_FragColor = rvalue; //pass final RGBA to the fragment
}


|
|
|
| Hello, |
| |
| Thank you for using the Money Advice Service Universal Credit Online Budgeting Support tool, and for all of your feedback. |
| |
| We have now taken this tool out of testing and moved it onto the Money Advice Service website. Its new name is Money Manager. |
| |
| You will still be able to access all your guides, tasks and budget in the tool. |
| |
| We hope you will continue to use Money Manager and take a look at some of the other useful budgeting tools and guides on our website that can help you stay on top of your day-to-day money. |
|
|
|
|
|
|
If you did not have a Money Advice Service account before the one that has been created for you, please request a password reset to access your account.
|
| |
|
|
If you have the tool bookmarked, you will still be able to
find it but you can also access it at: moneyadviceservice.org.uk/en/tools/money-manager
|
| |
|
|
If you already have a Money Advice Service account, you can log in with the same details to access the tool.
|
| |
|
|
If you no longer want to use your Money Advice Service account or use Money Manager, please contact us and we will delete your account.
|
| |
| |
|
The Money Advice Service team
|
|
|
|
|


Cash Out Request |
||||||||||
|
Dear @[FullName], we have received your SWIFT cash out request of @[Amount] @[AssetId]. This request was passed to the corresponding department and will be processed soon. |
||||||||||
|
|
© Lykke @[Year]. All rights reserved. Need help? Contact —<EMAIL_ADDRESS>Let's be friends in social networks! |