[1F 81 XX YY] - Works with items and the item usability byte in some unknown way.

UPDATE - SOLVED!
[1F 81 XX YY]: Check if item XX can be used by character YY, and store result in working memory.

C1/4F6F: C2 31        REP #$31         Flags and direct page madness
C1/4F71: 0B           PHD 
C1/4F72: 48           PHA 
C1/4F73: 7B           TDC 
C1/4F74: 69 EA FF     ADC #$FFEA
C1/4F77: 5B           TCD 
C1/4F78: 68           PLA 
C1/4F79: A9 01 00     LDA #$0001       A = 1
C1/4F7C: 18           CLC 
C1/4F7D: ED CA 97     SBC $97CA        V- N+ : 4F98
C1/4F80: 50 04        BVC $4F86        V+ N- : 4F98
C1/4F82: 10 17        BPL $4F9B        V+ N+ : 4F88
C1/4F84: 80 02        BRA $4F88        V- N- : 4F88
C1/4F86: 30 13        BMI $4F9B
C1/4F88: 8A           TXA              If overflow and negative are the same, do this. (Arguments to 97BA loop)
C1/4F89: E2 20        SEP #$20           Parameter to A, A becomes eight bit
C1/4F8B: AE CA 97     LDX $97CA          Load X with 97CA
C1/4F8E: 9D BA 97     STA $97BA,X        Store the parameter at 97BA indexed by X
C1/4F91: C2 20        REP #$20           A becomes sixteen bits
C1/4F93: EE CA 97     INC $97CA          Increment 97CA
C1/4F96: A9 6F 4F     LDA #$4F6F         A = 0x4F6F
C1/4F99: 80 3A        BRA $4FD5          Branch to 4FD5.
C1/4F9B: AD BA 97     LDA $97BA        If overflow and negative are different, do this. (Arguments are in 97BA)
C1/4F9E: 29 FF 00     AND #$00FF         Load accumulator with 97BA, modulo it by 0x100 (get arg 2)
C1/4FA1: 85 14        STA $14            Store arg 2 at $14
C1/4FA3: E0 00 00     CPX #$0000         Compare arg 1 to 0x0000
C1/4FA6: F0 04        BEQ $4FAC          If so, go to C14FAC
C1/4FA8: 86 12        STX $12            Store it in $12
C1/4FAA: 80 08        BRA $4FB4          Branch to 4FB4
C1/4FAC: 20 DC 03     JSR $03DC          If not, get the value through the variable-pass-handling stuff.
C1/4FAF: A5 06        LDA $06
C1/4FB1: AA           TAX 
C1/4FB2: 86 12        STX $12            (X, $12 = arg 1)
C1/4FB4: A5 14        LDA $14            Restore the moduloed-97BA accumulator (arg 2).
C1/4FB6: D0 05        BNE $4FBD          If nonzero, jump to C14FBD.
C1/4FB8: 20 0A 04     JSR $040A          If zero, go to C1040A, which is detailed in cc_0D.txt
C1/4FBB: A5 06        LDA $06
C1/4FBD: A6 12        LDX $12            Load X with parameter
C1/4FBF: 22 14 EE C3  JSR $C3EE14        C3EE14; A = arg 2, X = arg 1

C3/EE14: C2 31        REP #$31           Flags and direct page madness
C3/EE16: 0B           PHD 
C3/EE17: 48           PHA 
C3/EE18: 7B           TDC 
C3/EE19: 69 F0 FF     ADC #$FFF0
C3/EE1C: 5B           TCD 
C3/EE1D: 68           PLA 
C3/EE1E: 9B           TXY                Transfer X to Y and A to X, then store X at $0E; then transfer Y to A.
C3/EE1F: AA           TAX                Result: A = arg 1, X & $0E = arg 2.
C3/EE20: 86 0E        STX $0E
C3/EE22: 98           TYA 
C3/EE23: A0 27 00     LDY #$0027         Y = 0x27, A = arg 1.
C3/EE26: 22 F7 8F C0  JSR $C08FF7        A = arg 1 * 0x27. Arg 1 = AN ITEM NUMBER.
C3/EE2A: 18           CLC 
C3/EE2B: 69 1C 00     ADC #$001C         Clear carry, add 0x1C and transfer to X.
C3/EE2E: AA           TAX 
C3/EE2F: E2 20        SEP #$20           A = eight bit.
C3/EE31: BF 00 50 D5  LDA $D55000,X      Get one byte from position 0x1C in item number (arg1). This is ownership.
C3/EE35: A6 0E        LDX $0E            X = arg 2.
C3/EE37: CA           DEX                Decrement X.
C3/EE38: 3F AB 58 C4  AND $C458AB,X      Perform binary AND of the accumulator against $C458AB,X (45AAB,X).
C3/EE3C: C2 20        REP #$20           A = sixteen bit.
C3/EE3E: 29 FF 00     AND #$00FF         Clear high order bits.
C3/EE41: F0 05        BEQ $EE48          If zero, accumulator = 0. (Not usable.)
C3/EE43: A9 01 00     LDA #$0001         If nonzero, accumulator = 1. (Usable.)
C3/EE46: 80 03        BRA $EE4B
C3/EE48: A9 00 00     LDA #$0000
C3/EE4B: 2B           PLD 
C3/EE4C: 6B           RTL                Return.

C1/4FC3: 85 06        STA $06            Store accumulator in $06 and $0E
C1/4FC5: 64 08        STZ $08            Store zero in $08 and $10
C1/4FC7: A5 06        LDA $06
C1/4FC9: 85 0E        STA $0E
C1/4FCB: A5 08        LDA $08
C1/4FCD: 85 10        STA $10
C1/4FCF: 20 5D 04     JSR $045D          Jump to C1045D subroutine

C1/045D: C2 31        REP #$31           Flags and direct page madness
C1/045F: 0B           PHD 
C1/0460: 7B           TDC 
C1/0461: 69 F2 FF     ADC #$FFF2
C1/0464: 5B           TCD 
C1/0465: A5 1C        LDA $1C            Store $1C in $06 and $1E in $08.
C1/0467: 85 06        STA $06
C1/0469: A5 1E        LDA $1E
C1/046B: 85 08        STA $08
C1/046D: 20 01 03     JSR $0301          Jump to C10301, detailed in cc_0D.txt
C1/0470: 18           CLC 
C1/0471: 69 17 00     ADC #$0017         Clear carry, add 0x17 and transfer A to Y
C1/0474: A8           TAY 
C1/0475: A5 06        LDA $06            Store $06 at $0000 + Y
C1/0477: 99 00 00     STA $0000,Y
C1/047A: A5 08        LDA $08            Store $08 at $0002 + Y
C1/047C: 99 02 00     STA $0002,Y
C1/047F: A5 06        LDA $06            Store $06 at $14 and $08 at $16
C1/0481: 85 14        STA $14
C1/0483: A5 08        LDA $08
C1/0485: 85 16        STA $16
C1/0487: 2B           PLD 
C1/0488: 60           RTS                Return

C1/4FD2: A9 00 00     LDA #$0000         Nullify accumulator contents
C1/4FD5: 2B           PLD 
C1/4FD6: 60           RTS                Return