/* Metro module 821; source: unknown; dependencies: [57, 822, 823, 826] */
function _fun8943(global, require, importDefault, importAll, module, exports, dependencyMap) { // fn#8943, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:6, offset: 0x00d5778e, size: 192 bytes, params: 8, frame: 19
    var closure;
    let value = this;
    let env0_0 = require;
    const replaceExceptionFramesInException = function(a0, a1) {
        var value = undefined;
        if (a0 == null ? value : a0.stacktrace) {
            a0.stacktrace.frames = a1.reverse();
        }
        return value;
    };
    const Object = global.Object;
    Object.defineProperty(exports, '__esModule', {value: true});
    let env0_2 = importDefault(57) /* metro dependency 57 */;
    if (!(value && value.__awaiter)) {
        closure = function(a0, a1, a2, a3) {
            var r2;
            var value = a2;
            var env0_0 = a0;
            var env0_1 = a1;
            var env0_2 = value;
            var env0_3 = a3;
            r2 = value || global.Promise;
            value = Object.create(r2.prototype, {constructor: {value: r2}});
            var value2 = new r2(_fun8959);
            return value2 instanceof Object ? value2 : value;
        };
    }
    const RegExp = global.RegExp;
    const regExp = new RegExp(['ReactNativeRenderer-dev\\.js$', 'MessageQueue\\.js$'].join('|'));
    exports.debugSymbolicatorIntegration = function() {
        return {name: 'DebugSymbolicator', setupOnce: _fun8966, processEvent: processEvent};
    };
}

function processEvent(a0, a1) { // fn#8944, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:562, offset: 0x00d5784e, size: 43 bytes, params: 3, frame: 15
    const env0_0 = a0;
    const env0_1 = a1;
    return env0_3(this, undefined, undefined, _fun8946);
}

function symbolicate(a0) { // fn#8947, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:1562, offset: 0x00d57b63, size: 73 bytes, params: 2, frame: 18
    const env0_0 = a0;
    const value = 0;
    const env0_1 = arguments.length > 1 ? arguments[1] === undefined ? value : arguments[1] : value;
    return env0_3(this, undefined, undefined, _fun8949);
}

function _fun8958(a0, a1, a2, a3) { // fn#8958, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:132, offset: 0x00d57f0c, size: 75 bytes, params: 5, frame: 12
    let value = a2;
    const env0_0 = a0;
    const env0_1 = a1;
    const env0_3 = a3;
    let r2 = value || global.Promise;
    value = Object.create(r2.prototype, {constructor: {value: r2}});
    r2 = new r2(_fun8959);
    return r2 instanceof Object ? r2 : value;
}

function debugSymbolicatorIntegration() { // fn#8965, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:2713, offset: 0x00d580ad, size: 38 bytes, params: 1, frame: 2
    return {name: 'DebugSymbolicator', setupOnce: function() {
    }, processEvent: processEvent};
}

function* _fun8946() { // fn#8946, original name: ?anon_0_, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:624, offset: 0x00d57882, size: 737 bytes, params: 1, frame: 25
    var values;
    var r4;
    var r6;
    var stacktrace;
    var r3;
    var value4;
    var binding;
    var value5;
    var isErrorLike;
    var originalException;
    var syntheticException;
    var value6;
    var value7;
    var stack;
    var binding2;
    var value8;
    var getFramesToPop;
    var value9;
    var value10;
    var threads;
    var property;
    var reverse;
    var items2;
    var value11;
    var push;
    var cause;
    var value12;
    var entries;
    var iterator;
    var iterator2;
    var item;
    var item2;
    var value13;
    var property2;
    var binding3;
    var binding4;
    var property3;
    var value14;
    var value15;
    var value16;
    var value17;
    var value18;
    var error;
    if (false) {
        return undefined;
    }
    value = undefined;
    let exception = require.exception;
    env1_2 = exception;
    reducibleJoin4: while (true) {
        if (exception === null) {
            values = value;
            break reducibleJoin4;
        }
        if (value === env1_2) {
            values = value;
            break reducibleJoin4;
        }
        values = env1_2.values;
        break reducibleJoin4;
    }
    reducibleJoin33: while (true) {
        reducibleJoin60: while (true) {
            if (values) {
                value4 = environment.__proto__.__proto__;
                binding = env2_0;
                value5 = binding(env2_1[1]);
                isErrorLike = value5.isErrorLike;
                originalException = dependencyMap.originalException;
                if (Reflect.apply(isErrorLike, value5, [originalException])) {
                    originalException = dependencyMap.originalException;
                    items2 = [];
                    binding = env2_0;
                    value11 = binding(env2_1[1]);
                    isErrorLike = value11.isErrorLike;
                    if (Reflect.apply(isErrorLike, value11, [originalException])) {
                        r4 = originalException;
                        reducibleLoop30: while (true) {
                            push = items2.push;
                            Reflect.apply(push, items2, [r4]);
                            cause = r4.cause;
                            binding = env2_0;
                            value12 = binding(env2_1[1]);
                            isErrorLike = value12.isErrorLike;
                            if (Reflect.apply(isErrorLike, value12, [cause])) {
                                r4 = cause;
                                continue reducibleLoop30;
                            }
                            break reducibleLoop30;
                        }
                    }
                    entries = items2.entries;
                    iterator = Reflect.apply(entries, items2, [])[Symbol.iterator]();
                    iterator2 = iterator.next;
                    r3 = iterator;
                    item2 = Reflect.apply(iterator2, r3, []);
                    item = item2.value;
                    item2 = item2.done ? undefined : r3;
                    if (item2 === value) {
                        break reducibleJoin60;
                    }
                    break reducibleJoin33;
                }
                syntheticException = dependencyMap.syntheticException;
                if (syntheticException) {
                    value6 = environment.__proto__.__proto__;
                    binding = env2_0;
                    value7 = binding(env2_1[1]);
                    isErrorLike = value7.isErrorLike;
                    syntheticException = dependencyMap.syntheticException;
                    if (Reflect.apply(isErrorLike, value7, [syntheticException])) {
                        binding = env2_6;
                        syntheticException = dependencyMap.syntheticException;
                        stack = syntheticException.stack;
                        binding2 = env2_0;
                        value8 = binding2(env2_1[1]);
                        getFramesToPop = value8.getFramesToPop;
                        syntheticException = dependencyMap.syntheticException;
                        yield binding(stack, Reflect.apply(getFramesToPop, value8, [syntheticException]));
                        value9 = undefined;
                        value10 = false;
                        if (value10) {
                            return value9;
                        }
                        exception = require.exception;
                        if (exception) {
                            reducibleJoin26: while (true) {
                                if (value9) {
                                    exception = require.exception;
                                    values = exception.values;
                                    r4 = values;
                                    break reducibleJoin26;
                                }
                                r4 = value9;
                                break reducibleJoin26;
                            }
                            if (r4) {
                                binding = env2_7;
                                exception = require.exception;
                                values = exception.values;
                                binding(values[0], value9);
                                break reducibleJoin60;
                            }
                            break reducibleJoin60;
                        }
                        threads = require.threads;
                        r4 = threads && value9;
                        if (r4) {
                            threads = require.threads;
                            reducibleJoin16: while (true) {
                                if (threads === null) {
                                    values = value;
                                    break reducibleJoin16;
                                }
                                if (value === threads) {
                                    values = value;
                                    break reducibleJoin16;
                                }
                                values = threads.values;
                                break reducibleJoin16;
                            }
                            reducibleJoin19: while (true) {
                                if (values === null) {
                                    r6 = value;
                                    break reducibleJoin19;
                                }
                                if (value === values) {
                                    r6 = value;
                                    break reducibleJoin19;
                                }
                                property = values[0];
                                r6 = property;
                                break reducibleJoin19;
                            }
                            reducibleJoin22: while (true) {
                                if (r6 === null) {
                                    stacktrace = value;
                                    break reducibleJoin22;
                                }
                                if (value === r6) {
                                    stacktrace = value;
                                    break reducibleJoin22;
                                }
                                stacktrace = r6.stacktrace;
                                break reducibleJoin22;
                            }
                            if (stacktrace) {
                                threads = require.threads;
                                values = threads.values;
                                stacktrace = values[0].stacktrace;
                                reverse = value9.reverse;
                                stacktrace.frames = Reflect.apply(reverse, value9, []);
                                break reducibleJoin60;
                            }
                            break reducibleJoin60;
                        }
                        break reducibleJoin60;
                    }
                    break reducibleJoin60;
                }
                break reducibleJoin60;
            }
            syntheticException = dependencyMap.syntheticException;
            if (syntheticException) {
                value6 = environment.__proto__.__proto__;
                binding = env2_0;
                value7 = binding(env2_1[1]);
                isErrorLike = value7.isErrorLike;
                syntheticException = dependencyMap.syntheticException;
                if (Reflect.apply(isErrorLike, value7, [syntheticException])) {
                    binding = env2_6;
                    syntheticException = dependencyMap.syntheticException;
                    stack = syntheticException.stack;
                    binding2 = env2_0;
                    value8 = binding2(env2_1[1]);
                    getFramesToPop = value8.getFramesToPop;
                    syntheticException = dependencyMap.syntheticException;
                    yield binding(stack, Reflect.apply(getFramesToPop, value8, [syntheticException]));
                    value9 = undefined;
                    value10 = false;
                    if (value10) {
                        return value9;
                    }
                    exception = require.exception;
                    if (exception) {
                        reducibleJoin26: while (true) {
                            if (value9) {
                                exception = require.exception;
                                values = exception.values;
                                r4 = values;
                                break reducibleJoin26;
                            }
                            r4 = value9;
                            break reducibleJoin26;
                        }
                        if (r4) {
                            binding = env2_7;
                            exception = require.exception;
                            values = exception.values;
                            binding(values[0], value9);
                            break reducibleJoin60;
                        }
                        break reducibleJoin60;
                    }
                    threads = require.threads;
                    r4 = threads && value9;
                    if (r4) {
                        threads = require.threads;
                        reducibleJoin16: while (true) {
                            if (threads === null) {
                                values = value;
                                break reducibleJoin16;
                            }
                            if (value === threads) {
                                values = value;
                                break reducibleJoin16;
                            }
                            values = threads.values;
                            break reducibleJoin16;
                        }
                        reducibleJoin19: while (true) {
                            if (values === null) {
                                r6 = value;
                                break reducibleJoin19;
                            }
                            if (value === values) {
                                r6 = value;
                                break reducibleJoin19;
                            }
                            property = values[0];
                            r6 = property;
                            break reducibleJoin19;
                        }
                        reducibleJoin22: while (true) {
                            if (r6 === null) {
                                stacktrace = value;
                                break reducibleJoin22;
                            }
                            if (value === r6) {
                                stacktrace = value;
                                break reducibleJoin22;
                            }
                            stacktrace = r6.stacktrace;
                            break reducibleJoin22;
                        }
                        if (stacktrace) {
                            threads = require.threads;
                            values = threads.values;
                            stacktrace = values[0].stacktrace;
                            reverse = value9.reverse;
                            stacktrace.frames = Reflect.apply(reverse, value9, []);
                            break reducibleJoin60;
                        }
                        break reducibleJoin60;
                    }
                    break reducibleJoin60;
                }
                break reducibleJoin60;
            }
            break reducibleJoin60;
        }
        return require;
    }
    reducibleLoop33: while (true) {
        try {
            binding = env2_2;
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            value13 = binding(item, 2);
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            property = value13[0];
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            property2 = value13[1];
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            binding = env2_6;
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            stack = property2.stack;
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            binding3 = env2_0;
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            binding4 = env2_1;
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            property3 = binding4[1];
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            value14 = binding3(property3);
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            getFramesToPop = value14.getFramesToPop;
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            value15 = Reflect.apply(getFramesToPop, value14, [property2]);
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        try {
            value16 = binding(stack, value15);
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        yield value16;
        try {
            value17 = undefined;
            value18 = false;
        } catch (error) {
            try {
                item2.return();
            } catch {
            }
            throw error;
        }
        if (value18) {
            item2.return();
            return value17;
        }
        reducibleJoin32: while (true) {
            if (value17) {
                try {
                    binding = env2_7;
                } catch (error) {
                    try {
                        item2.return();
                    } catch {
                    }
                    throw error;
                }
                try {
                } catch (error) {
                    try {
                        item2.return();
                    } catch {
                    }
                    throw error;
                }
                try {
                    exception = require.exception;
                } catch (error) {
                    try {
                        item2.return();
                    } catch {
                    }
                    throw error;
                }
                try {
                    values = exception.values;
                } catch (error) {
                    try {
                        item2.return();
                    } catch {
                    }
                    throw error;
                }
                try {
                    property = values[property];
                } catch (error) {
                    try {
                        item2.return();
                    } catch {
                    }
                    throw error;
                }
                try {
                    binding(property, value17);
                } catch (error) {
                    try {
                        item2.return();
                    } catch {
                    }
                    throw error;
                }
                r3 = item2;
                break reducibleJoin32;
            }
            r3 = item2;
            break reducibleJoin32;
        }
        item2 = Reflect.apply(iterator2, r3, []);
        item = item2.value;
        item2 = item2.done ? undefined : r3;
        if (item2 === value) {
            return require;
        }
        continue reducibleLoop33;
    }
}

function* _fun8949() { // fn#8949, original name: ?anon_0_, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:1678, offset: 0x00d57bb5, size: 410 bytes, params: 1, frame: 24
    var environment;
    var r10;
    var r9;
    var binding;
    var binding2;
    var property;
    var value3;
    var parseErrorStack;
    var errorStack;
    var value5;
    var symbolicateStackTrace;
    var value6;
    var value7;
    var value8;
    var binding3;
    var value9;
    var debug;
    var error;
    var value10;
    var stack;
    var Math;
    var max;
    var value11;
    var value12;
    var slice;
    var value13;
    var filter;
    var closure;
    var value14;
    var value15;
    var value16;
    var value17;
    var binding4;
    var value18;
    var fetchSourceContext;
    var sourceContext;
    var value19;
    var value20;
    var Error;
    var warn;
    var message;
    if (false) {
        return undefined;
    }
    value = environment.__proto__.__proto__;
    try {
        binding = env2_0;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        binding2 = env2_1;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        property = binding2[2];
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        value3 = binding(property);
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        parseErrorStack = value3.parseErrorStack;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        errorStack = Reflect.apply(parseErrorStack, value3, [require]);
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        property = binding2[2];
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        value5 = binding(property);
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        symbolicateStackTrace = value5.symbolicateStackTrace;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        value6 = Reflect.apply(symbolicateStackTrace, value5, [errorStack]);
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    yield value6;
    try {
        value7 = undefined;
        value8 = false;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    if (value8) {
        return value7;
    }
    if (value7) {
        try {
            value10 = 'stack' in value7;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        if (value10) {
            try {
                stack = value7.stack;
                r10 = stack;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                Math = global.Math;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                max = Math.max;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value11 = dependencyMap - 1;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value12 = Reflect.apply(max, Math, [value11, 0]);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            if (value12) {
                try {
                    slice = r10.slice;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    value13 = Reflect.apply(slice, r10, [value12]);
                    r9 = value13;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    filter = r9.filter;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    closure = _fun8950;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    value14 = Reflect.apply(filter, r9, [closure]);
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    closure = convertReactNativeFramesToSentryFrames;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    value15 = closure(value14);
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                yield value15;
                try {
                    value16 = undefined;
                    value17 = false;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                if (value17) {
                    return value16;
                }
                try {
                    binding = env2_0;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    binding4 = env2_1;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    property = binding4[2];
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    value18 = binding(property);
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    fetchSourceContext = value18.fetchSourceContext;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                try {
                    sourceContext = Reflect.apply(fetchSourceContext, value18, [value16]);
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                yield sourceContext;
                try {
                    value19 = undefined;
                    value20 = false;
                } catch (error) {
                    Error = global.Error;
                    if (error instanceof Error) {
                        binding = env2_0;
                        debug = binding(env2_1[3]).debug;
                        warn = debug.warn;
                        message = error.message;
                        Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                    }
                    return null;
                }
                return value20 ? value19 : value19;
            }
            r9 = r10;
            try {
                filter = r9.filter;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                closure = _fun8950;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value14 = Reflect.apply(filter, r9, [closure]);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                closure = convertReactNativeFramesToSentryFrames;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value15 = closure(value14);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            yield value15;
            try {
                value16 = undefined;
                value17 = false;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            if (value17) {
                return value16;
            }
            try {
                binding = env2_0;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                binding4 = env2_1;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                property = binding4[2];
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value18 = binding(property);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                fetchSourceContext = value18.fetchSourceContext;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                sourceContext = Reflect.apply(fetchSourceContext, value18, [value16]);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            yield sourceContext;
            try {
                value19 = undefined;
                value20 = false;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            return value20 ? value19 : value19;
        }
        r10 = value7;
        try {
            Math = global.Math;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            max = Math.max;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            value11 = dependencyMap - 1;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            value12 = Reflect.apply(max, Math, [value11, 0]);
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        if (value12) {
            try {
                slice = r10.slice;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value13 = Reflect.apply(slice, r10, [value12]);
                r9 = value13;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                filter = r9.filter;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                closure = _fun8950;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value14 = Reflect.apply(filter, r9, [closure]);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                closure = convertReactNativeFramesToSentryFrames;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value15 = closure(value14);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            yield value15;
            try {
                value16 = undefined;
                value17 = false;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            if (value17) {
                return value16;
            }
            try {
                binding = env2_0;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                binding4 = env2_1;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                property = binding4[2];
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                value18 = binding(property);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                fetchSourceContext = value18.fetchSourceContext;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            try {
                sourceContext = Reflect.apply(fetchSourceContext, value18, [value16]);
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            yield sourceContext;
            try {
                value19 = undefined;
                value20 = false;
            } catch (error) {
                Error = global.Error;
                if (error instanceof Error) {
                    binding = env2_0;
                    debug = binding(env2_1[3]).debug;
                    warn = debug.warn;
                    message = error.message;
                    Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
                }
                return null;
            }
            return value20 ? value19 : value19;
        }
        r9 = r10;
        try {
            filter = r9.filter;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            closure = _fun8950;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            value14 = Reflect.apply(filter, r9, [closure]);
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            closure = convertReactNativeFramesToSentryFrames;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            value15 = closure(value14);
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        yield value15;
        try {
            value16 = undefined;
            value17 = false;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        if (value17) {
            return value16;
        }
        try {
            binding = env2_0;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            binding4 = env2_1;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            property = binding4[2];
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            value18 = binding(property);
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            fetchSourceContext = value18.fetchSourceContext;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        try {
            sourceContext = Reflect.apply(fetchSourceContext, value18, [value16]);
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        yield sourceContext;
        try {
            value19 = undefined;
            value20 = false;
        } catch (error) {
            Error = global.Error;
            if (error instanceof Error) {
                binding = env2_0;
                debug = binding(env2_1[3]).debug;
                warn = debug.warn;
                message = error.message;
                Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
            }
            return null;
        }
        return value20 ? value19 : value19;
    }
    try {
        binding = env2_0;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        binding3 = env2_1;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        property = binding3[3];
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        value9 = binding(property);
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        debug = value9.debug;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        error = debug.error;
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    try {
        Reflect.apply(error, debug, ['React Native DevServer could not symbolicate the stack trace.']);
    } catch (error) {
        Error = global.Error;
        if (error instanceof Error) {
            binding = env2_0;
            debug = binding(env2_1[3]).debug;
            warn = debug.warn;
            message = error.message;
            Reflect.apply(warn, debug, ['Unable to symbolicate stack trace: ' + message]);
        }
        return null;
    }
    return null;
}

function _fun8959(a0, a1) { // fn#8959, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:178, offset: 0x00d57f57, size: 98 bytes, params: 3, frame: 16
    const env0_0 = a0;
    const env0_1 = a1;
    const closure = step;
    const value2 = importAll.apply(env0_0, require || []);
    closure(value2.next());
}

function _fun8950(a0) { // fn#8950, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:1944, offset: 0x00d57d4f, size: 44 bytes, params: 2, frame: 12
    var r0;
    var match;
    var value;
    let file = a0.file;
    if (file) {
        file = a0.file;
        match = file.match;
        value = environment.__proto__.__proto__.__proto__;
        value = Reflect.apply(match, file, [env3_4]);
        value = value === null;
        r0 = value;
    } else {
        r0 = file;
    }
    return r0;
}

function convertReactNativeFramesToSentryFrames(a0) { // fn#8951, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:2005, offset: 0x00d57d7b, size: 36 bytes, params: 2, frame: 15
    const env0_0 = a0;
    return env3_3(this, undefined, undefined, _fun8953);
}

function step(a0) { // fn#8962, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:306, offset: 0x00d5802a, size: 77 bytes, params: 2, frame: 14
    var value;
    if (a0.done) {
        env0_0(a0.value);
    } else {
        value = a0.value;
        value = stepAdopt(value);
        value.then(fulfilled, rejected);
    }
}

function* _fun8953() { // fn#8953, original name: ?anon_0_, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:2085, offset: 0x00d57da8, size: 63 bytes, params: 1, frame: 14
    var environment;
    if (false) {
        return undefined;
    }
    const Promise = global.Promise;
    const all = Promise.all;
    value = environment.__proto__;
    const binding = env1_0;
    return Reflect.apply(all, Promise, [binding.map(_fun8954)]);
}

function stepAdopt(a0) { // fn#8963, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:341, owner: step.adopt, offset: 0x00d58077, size: 54 bytes, params: 2, frame: 12
    const value = a0;
    return value instanceof env2_2 ? value : new env2_2(_fun8964);
}

function _fun8954(a0) { // fn#8954, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:2134, offset: 0x00d57de7, size: 40 bytes, params: 2, frame: 15
    return env6_3(a0, undefined, undefined, _fun8956);
}

function* _fun8956() { // fn#8956, original name: ?anon_0_, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:948:2172, offset: 0x00d57e18, size: 192 bytes, params: 1, frame: 14
    if (false) {
        return undefined;
    }
    value = environment.__proto__;
    const column = env1_0.column;
    let r2 = (column ? !!env1_0.lineNumber : !!column) && env1_0.file !== undefined;
    r2 = r2 && !env1_0.file.includes('node_modules') && !env1_0.file.includes('native code');
    const binding = env1_0;
    return {lineno: binding.lineNumber, colno: binding.column, filename: binding.file, function: binding.methodName,
        in_app: r2};
}