fn flush_instrs()

in starlark/src/eval/bc/writer.rs [116:190]
72 lines of code
3 McCabe index (conditional complexity)

    fn flush_instrs(&mut self) {
        let mut queued_locals = mem::take(&mut self.queued_locals);
        let mut queued_consts = mem::take(&mut self.queued_consts);
        let mut locals_slice = queued_locals.as_slice();
        let mut consts_slice = queued_consts.as_slice();

        while let [l0, l1, l2, l3, rem @ ..] = locals_slice {
            self.do_write_generic_explicit::<InstrLoadLocal4>(
                BcInstrSlowArg {
                    span: l0.span.merge(&l1.span).merge(&l2.span).merge(&l3.span),
                    spans: vec![l0.span, l1.span, l2.span, l3.span],
                },
                [l0.node, l1.node, l2.node, l3.node],
            );
            locals_slice = rem;
        }
        match (locals_slice, consts_slice) {
            ([], _) => {}
            ([l0], [c0, rem @ ..]) => {
                self.do_write_generic::<InstrLoadLocalAndConst>(l0.span, (l0.node, c0.node));
                consts_slice = rem;
            }
            ([l0], _) => {
                self.do_write_generic::<InstrLoadLocal>(l0.span, l0.node);
            }
            ([l0, l1], _) => {
                self.do_write_generic_explicit::<InstrLoadLocal2>(
                    BcInstrSlowArg {
                        span: l0.span.merge(&l1.span),
                        spans: vec![l0.span, l1.span],
                    },
                    [l0.node, l1.node],
                );
            }
            ([l0, l1, l2], _) => {
                self.do_write_generic_explicit::<InstrLoadLocal3>(
                    BcInstrSlowArg {
                        span: l0.span.merge(&l1.span).merge(&l2.span),
                        spans: vec![l0.span, l1.span, l2.span],
                    },
                    [l0.node, l1.node, l2.node],
                );
            }
            _ => unreachable!(),
        }

        while let [v0, v1, v2, v3, rem @ ..] = consts_slice {
            self.do_write_generic::<InstrConst4>(
                v0.span.merge(&v1.span).merge(&v2.span).merge(&v3.span),
                [v0.node, v1.node, v2.node, v3.node],
            );
            consts_slice = rem;
        }
        match consts_slice {
            [] => {}
            [v0] => {
                self.do_write_generic::<InstrConst>(v0.span, v0.node);
            }
            [v0, v1] => {
                self.do_write_generic::<InstrConst2>(v0.span.merge(&v1.span), [v0.node, v1.node]);
            }
            [v0, v1, v2] => {
                self.do_write_generic::<InstrConst3>(
                    v0.span.merge(&v1.span).merge(&v2.span),
                    [v0.node, v1.node, v2.node],
                );
            }
            _ => unreachable!(),
        }

        queued_locals.clear();
        queued_consts.clear();
        self.queued_locals = queued_locals;
        self.queued_consts = queued_consts;
    }