// Decompiled by JEB v0.9.0 alpha

public static int lzss_decompress(byte[] arg12, byte[] arg13) {
    int v9 = -1;
    int v2 = 0;
    int v4 = 0;
    int v1 = 0;
    int v0 = 7;
    while(v4 < arg13.length) {
        ++v0;
        if(v0 == 8) {
            if(v2 < arg12.length) {
                v1 = arg12[v2] & 0xFF;
                v0 = 0;
                ++v2;
            }
            else {
                break;
            }

        }

        if((v1 & 1) != 0) {
            if(v2 + 1 < arg12.length) {
                int v8 = arg12[v2] & 0xFF | (arg12[v2 + 1] & 0xFF) << 8;
                v2 += 2;
                int v7 = (v8 >> 4) + 1;
                int v6 = (v8 & 0xF) + 3;
                if(v7 > v4) {
                    v4 = v9;
                    break;
                }
                else if(arg13.length - v4 < v6) {
                    v4 = v9;
                    break;
                }
                else {
                    int v5 = 0;
                    while(v5 < v6) {
                        arg13[v4 + v5] = arg13[v4 + v5 - v7];
                        ++v5;
                    }

                    v4 += v6;
                }

            }
            else {
                v4 = v9;
                break;
            }

        }
        else if(v2 < arg12.length) {
            arg13[v4] = arg12[v2];
            ++v4;
            ++v2;
        }
        else {
            break;
        }

        v1 >>= 1;
    }

    return v4;
}

/**
 * Decompress a LZSS byte stream.
 * @param in input buffer
 * @param out output buffer
 * @return size of decompressed data, -1 on error
 */
public static int lzss_decompress(byte[] in, byte[] out) {
    int i = 0;
    int j = 0;
    int flags = 0;
    int cnt = 7;
    
    while(j < out.length) {

        if(++cnt == 8) {
            if(i >= in.length) {
                break;
            }
            flags = in[i++] & 0xFF;
            cnt = 0;
        }
        
        if((flags & 1) == 0) {
            if(i >= in.length) {
                break;
            }
            out[j] = in[i];
            j++;
            i++;
        }
        else {
            if((i + 1) >= in.length) {
                return -1;
            }
            int v = (in[i] & 0xFF) | (in[i+1] & 0xFF) << 8;
            i += 2;
            
            int offset = (v >> 4) + 1;
            int length = (v & 0xF) + 3;

            // not enough data decoded
            if(offset > j) {
                return -1;
            }

            // output buffer is too small
            if((out.length - j) < length) {
                return -1;
            }

            for(int k = 0; k < length; k++) {
                out[j+k] = out[j+k-offset];
            }
            j += length;
        }

        flags >>= 1;
    }

    return j;
}