// introduce breaks between other categories grouped in Letter. However, this
// is undesirable for our purposes. ICU prevents breaks in such cases as well.

// isBreak returns whether this rune should introduce a break.
func (c info) isBreak() bool {
	return c.cccVal() == cccBreak
}

// isLetter returns whether the rune is of break type ALetter, Hebrew_Letter,
// Numeric, ExtendNumLet, or Extend.

		if p.isCased() {
			if !c.isMidWord {
				if !t.title(c) {
					break
				}
				c.isMidWord = true
			} else if !t.lower(c) {
				break
			}
		} else if !c.copy() {
			break
		} else if p.isBreak() {
			c.isMidWord = false
		}

		// As we save the state of the transformer, it is safe to call
		// checkpoint after any successful write.
		if !(c.isMidWord && wasMid) {
			c.checkpoint()
		}

                    ReferenceAccess.WRITE -> arrayOf(KaFirSimpleNameReference(nameReferenceExpression, isRead = false))
                    ReferenceAccess.READ_WRITE -> arrayOf(
                        KaFirSimpleNameReference(nameReferenceExpression, isRead = true),
                        KaFirSimpleNameReference(nameReferenceExpression, isRead = false),
                    )
                }

    @Inject
    public DefaultConfigurableUserClassFilePermissions(int unixNumeric) {
        setRead(isRead(unixNumeric));
        setWrite(isWrite(unixNumeric));
        setExecute(isExecute(unixNumeric));
    }

    @Override
    public void unix(String unixSymbolic) {
        setRead(isRead(unixSymbolic));
        setWrite(isWrite(unixSymbolic));
        setExecute(isExecute(unixSymbolic));
    }

     */
    protected int toUnixNumeric() {
        return (getRead() ? 4 : 0) + (getWrite() ? 2 : 0) + (getExecute() ? 1 : 0);
    }

    protected static boolean isRead(int unixNumeric) {
        return (unixNumeric & 4) >> 2 == 1;
    }

    protected static boolean isRead(String unixSymbolic) {
        char symbol = unixSymbolic.charAt(0);
        if (symbol == 'r') {
            return true;
        } else if (symbol == '-') {

import org.jetbrains.kotlin.fir.psi
import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
import org.jetbrains.kotlin.psi.*

internal class KaFirSimpleNameReference(
    expression: KtSimpleNameExpression,
    val isRead: Boolean,
) : KtSimpleNameReference(expression), KaFirReference {

    private val isAnnotationCall: Boolean
        get() {
            val ktUserType = expression.parent as? KtUserType ?: return false

    private final boolean read;
    private final boolean write;
    private final boolean execute;

    public DefaultUserClassFilePermissions(int unixNumeric) {
        read = isRead(unixNumeric);
        write = isWrite(unixNumeric);
        execute = isExecute(unixNumeric);
    }

    @Override
    public boolean getRead() {
        return read;
    }

    @Override

	return false
}

func cipherRC4(key, iv []byte, isRead bool) any {
	cipher, _ := rc4.NewCipher(key)
	return cipher
}

func cipher3DES(key, iv []byte, isRead bool) any {
	block, _ := des.NewTripleDESCipher(key)
	if isRead {
		return cipher.NewCBCDecrypter(block, iv)
	}
	return cipher.NewCBCEncrypter(block, iv)
}

func cipherAES(key, iv []byte, isRead bool) any {
	block, _ := aes.NewCipher(key)

        }
    }

    private static String toUnixSymbolic(int unitNumeric) {
        return String.format("%s%s%s", isRead(unitNumeric) ? "r" : "-", isWrite(unitNumeric) ? "w" : "-", isExecute(unitNumeric) ? "x" : "-");
    }

    private static boolean isRead(int unixNumeric) {
        return (unixNumeric & 4) >> 2 == 1;
    }

    private static boolean isWrite(int unixNumeric) {

	"FSGNJNQ",
	"FSGNJXQ",
	"FEQQ",
	"FLEQ",
	"FLTQ",
	"FCLASSQ",
	"CSRRW",
	"CSRRS",
	"CSRRC",
	"CSRRWI",
	"CSRRSI",
	"CSRRCI",
	"ECALL",
	"SCALL",
	"EBREAK",
	"SBREAK",
	"MRET",
	"SRET",
	"DRET",
	"WFI",
	"SFENCEVMA",
	"ADDUW",
	"SH1ADD",
	"SH1ADDUW",
	"SH2ADD",
	"SH2ADDUW",
	"SH3ADD",
	"SH3ADDUW",
	"SLLIUW",
	"ANDN",
	"ORN",