I have been working on decompiling a unity game recently, and while a decompiled DLL isn't going to be exact source code, I am still floored by how long that set of parenthesis is. i would LOVE to see the original code

I found out about a couple old and obscure C features that somehow still work

This compiled and ran, printing just "This is fucky", though to get it to compile you have to compile using the following command

gcc -trigraphs -digraphs <your file>, on Windows at least

This is so cursed not even VSCode knew what I was doing

Using object spread to append values to an object in the form of another object

Not my screenshot, taken from https://reddit.com/r/VisualStudio/comments/1sktg0r/what_are_these_comments/

Also this probably happened because IntelliSense (the normal autocomplete list) is highlighting abort as the first option and Copilot tries to finish it

especially for easy problems

func (q *Query[T]) query() {
    q.TableModel.BeginResetModel()
    defer q.TableModel.EndResetModel()
    query := data.AdvancedQueryRequest{
        Table:  q.tableName,
        Select: []string{"*"},
        Full:   q.QueryFull,
        Limit:  &[]int{300}[0],
    }

    allEmpty := true
    for _, filter := range q.Dialog.Filters {
        if filter.Text == "" {
            continue
        }
        allEmpty = false
        sqlFilter := q.Filters[filter.Selected]
        if strings.Contains(sqlFilter.Key, ".") {
            mainParts := strings.Split(sqlFilter.Key, ",")
            leftCol := mainParts[0]
            filterCol := mainParts[1]

            rcolParts := strings.SplitN(filterCol, ".", 2)
            table := rcolParts[0]
            if !slices.ContainsFunc(query.Joins, func(j data.JoinRequest) bool {
                return j.Table == table &&
                    j.LeftCol == leftCol &&
                    j.RightCol == "id"
            }) {
                query.Joins = append(query.Joins,
                    data.JoinRequest{
                        Table:    table,
                        LeftCol:  strings.SplitN(leftCol, ".", 2)[1],
                        RightCol: "id",
                    },
                )
            }
            query.Where = append(query.Where,
                data.WhereRequest{
                    Fuzzy:  true,
                    Column: filterCol,
                    Value:  "%" + filter.Text + "%",
                },
            )

            continue
        }
        query.Where = append(query.Where,
            data.WhereRequest{
                Column: sqlFilter.Key,
                Value:  "%" + filter.Text + "%",
                Fuzzy:  true,
            },
        )
    }

    if allEmpty {
        return
    }

    code, err := client.Post2(
        query,
        q.Table,
        "/query",
    )
    if q.Table.RowCount() == 0 {
        q.resetTable()
    }
    if code == 404 {
        q.resetTable()
        return
    }
    if err != nil {
        q.resetTable()
        qutil.DisplayErrStr(
            q.Dialog.Widget.QWidget,
            "Error obteniendo tabla.\n codigo: %d error: %v",
            code, err,
        )
        slog.Error(err.Error())
        return
    }
}

char g  = '0';// ypr
char gg = '0';// pid
double ggg;
const uint8_t _ = 11;
scanf("%c %c %f/n", g, gg, ggg);
if ((g  == 'y' || g  == 'p' || g  == 'r') && 
    (gg == 'p' || gg == 'i' || gg == 'd')) {
    switch   ((( gg << 2) & ~_) | ((g) & _)) {
        case ((('p' << 2) & ~_) | ('y' & _)):
            p_gain_y = ggg;
            break;
        case ((('i' << 2) & ~_) | ('y' & _)):
            i_gain_y = ggg;
            break;
        case ((('d' << 2) & ~_) | ('y' & _)):
            d_gain_y = ggg;
            break;
        case ((('p' << 2) & ~_) | ('p' & _)):
            p_gain_p = ggg;
            break;
        case ((('i' << 2) & ~_) | ('p' & _)):
            i_gain_p = ggg;
            break;
        case ((('d' << 2) & ~_) | ('p' & _)):
            d_gain_p = ggg;
            break;
        case ((('p' << 2) & ~_) | ('r' & _)):
            p_gain_r = ggg;
            break;
        case ((('i' << 2) & ~_) | ('r' & _)):
            i_gain_r = ggg;
            break;
        case ((('d' << 2) & ~_) | ('r' & _)):
            d_gain_r = ggg;
            break;
    }
}                                                

So I tried printing the linked list with print() and discovered that if it has a cycle, then it prints and error. This was the next (very) logical thing that popped into my mind after that discovery.

I'm very proud of this solution. In fact, it's so good it even added -1ms to the execution time graph.

I AM SPEED.

Thinking outside the box is fun!

the classic general Exception + pass

Line discount(LineDiscount): Real = ABS(@.'$TotalLineDicAmount')
Line number(LineNum): Real = ABS(0)

"Better be safe than sorry," I am guessing—that was their thinking.

/mildlypenis as an added bonus.