[DAG] SDPatternMatch - add m_Negative/m_StrictlyPositive/m_NonNegative/m_NonPositive/m_NonZero matchers by ak1932 · Pull Request #175191 · llvm/llvm-project

ak1932 · 2026-01-09T15:56:50Z

wip: Still need to find a fold in DAGCombiner and add more extensive unit testing.

github-actions · 2026-01-09T15:57:11Z

Thank you for submitting a Pull Request (PR) to the LLVM Project!

This PR will be automatically labeled and the relevant teams will be notified.

If you wish to, you can add reviewers by using the "Reviewers" section on this page.

If this is not working for you, it is probably because you do not have write permissions for the repository. In which case you can instead tag reviewers by name in a comment by using @ followed by their GitHub username.

If you have received no comments on your PR for a week, you can request a review by "ping"ing the PR by adding a comment “Ping”. The common courtesy "ping" rate is once a week. Please remember that you are asking for valuable time from other developers.

If you have further questions, they may be answered by the LLVM GitHub User Guide.

You can also ask questions in a comment on this PR, on the LLVM Discord or on the forums.

ak1932 · 2026-01-09T15:57:33Z

@RKSimon, Am i on the right track?

llvmbot · 2026-01-09T15:57:44Z

@llvm/pr-subscribers-llvm-selectiondag

Author: Aryan Kadole (ak1932)

Changes

wip: Still need to find a fold in DAGCombiner and add more extensive unit testing.

Resolves #174327

Full diff: https://github.com/llvm/llvm-project/pull/175191.diff

4 Files Affected:

(modified) llvm/include/llvm/CodeGen/SDPatternMatch.h (+55)
(modified) llvm/include/llvm/CodeGen/SelectionDAG.h (+15)
(modified) llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp (+44)
(modified) llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp (+16)

diff --git a/llvm/include/llvm/CodeGen/SDPatternMatch.h b/llvm/include/llvm/CodeGen/SDPatternMatch.h
index 026ee035fcf54..6cf3bb115448e 100644
--- a/llvm/include/llvm/CodeGen/SDPatternMatch.h
+++ b/llvm/include/llvm/CodeGen/SDPatternMatch.h
@@ -1173,6 +1173,46 @@ inline SpecificFP_match m_SpecificFP(double V) {
   return SpecificFP_match(APFloat(V));
 }
 
+struct Negative_match {
+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNegative(N) : false;
+  }
+};
+
+struct NonNegative_match {
+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNonNegative(N) : false;
+  }
+};
+
+struct StrictlyPositive_match {
+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsStrictlyPositive(N) : false;
+  }
+};
+
+struct NonPositive_match {
+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNonPositive(N) : false;
+  }
+};
+
+struct NonZero_match {
+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNonZero(N) : false;
+  }
+};
+
 struct Zero_match {
   bool AllowUndefs;
 
@@ -1204,6 +1244,21 @@ struct AllOnes_match {
   }
 };
 
+inline Negative_match m_Negative() {
+  return Negative_match();
+}
+inline NonNegative_match m_NonNegative() {
+  return NonNegative_match();
+}
+inline StrictlyPositive_match m_StrictlyPositive() {
+  return StrictlyPositive_match();
+}
+inline NonPositive_match m_NonPositive() {
+  return NonPositive_match();
+}
+inline NonZero_match m_NonZero() {
+  return NonZero_match();
+}
 inline Ones_match m_One(bool AllowUndefs = false) {
   return Ones_match(AllowUndefs);
 }
diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h
index 4c7c9942fb8f6..4c760ee79cc41 100644
--- a/llvm/include/llvm/CodeGen/SelectionDAG.h
+++ b/llvm/include/llvm/CodeGen/SelectionDAG.h
@@ -2077,6 +2077,21 @@ class SelectionDAG {
   /// floating-point value.
   LLVM_ABI bool SignBitIsZeroFP(SDValue Op, unsigned Depth = 0) const;
 
+  /// Return true if Op is strictly positive FP or integer
+  LLVM_ABI bool IsStrictlyPositive(SDValue Op, unsigned Depth = 0) const;
+
+  /// Return true if Op is non positive FP or integer
+  LLVM_ABI bool IsNonPositive(SDValue Op, unsigned Depth = 0) const;
+
+  /// Return true if Op is a Negative FP or integer
+  LLVM_ABI bool IsNegative(SDValue Op, unsigned Depth = 0) const;
+
+  /// Return true if Op is non negative
+  LLVM_ABI bool IsNonNegative(SDValue Op, unsigned Depth = 0) const;
+
+  /// Return true if Op is non zero
+  LLVM_ABI bool IsNonZero(SDValue Op, unsigned Depth = 0) const;
+
   /// Return true if 'Op & Mask' is known to be zero.  We
   /// use this predicate to simplify operations downstream.  Op and Mask are
   /// known to be the same type.
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index 891f584cf0c3a..fd848633f9fdc 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -2834,6 +2834,50 @@ bool SelectionDAG::SignBitIsZeroFP(SDValue Op, unsigned Depth) const {
   llvm_unreachable("covered opcode switch");
 }
 
+bool SelectionDAG::IsNegative(SDValue Op, unsigned Depth) const {
+  if (Op.getValueType().isScalarInteger()
+      || Op.getValueType().isFloatingPoint()) {
+    KnownBits KB = computeKnownBits(Op);
+    return KB.isNegative();
+  }
+
+  return false;
+}
+
+bool SelectionDAG::IsNonNegative(SDValue Op, unsigned Depth) const {
+  if (Op.getValueType().isScalarInteger()
+      || Op.getValueType().isFloatingPoint()) {
+    KnownBits KB = computeKnownBits(Op);
+    return KB.isNonNegative();
+  }
+
+  return false;
+}
+
+bool SelectionDAG::IsStrictlyPositive(SDValue Op, unsigned Depth) const {
+  if (Op.getValueType().isScalarInteger()
+      || Op.getValueType().isFloatingPoint()) {
+    KnownBits KB = this->computeKnownBits(Op);
+    return KB.isStrictlyPositive();
+  }
+
+  return false;
+}
+
+bool SelectionDAG::IsNonPositive(SDValue Op, unsigned Depth) const {
+  return !IsStrictlyPositive(Op);
+}
+
+bool SelectionDAG::IsNonZero(SDValue Op, unsigned Depth) const {
+  if (Op.getValueType().isScalarInteger()
+      || Op.getValueType().isFloatingPoint()) {
+    KnownBits KB = computeKnownBits(Op);
+    return KB.isNonZero();
+  }
+
+  return false;
+}
+
 /// MaskedValueIsZero - Return true if 'V & Mask' is known to be zero.  We use
 /// this predicate to simplify operations downstream.  Mask is known to be zero
 /// for bits that V cannot have.
diff --git a/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp b/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
index 1afc034dd7b9e..8d2e8627f1d9f 100644
--- a/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
+++ b/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
@@ -556,6 +556,7 @@ TEST_F(SelectionDAGPatternMatchTest, matchConstants) {
   SDValue ConstSplat = DAG->getSplat(VInt32VT, DL, Const3);
   SDValue Zero = DAG->getConstant(0, DL, Int32VT);
   SDValue One = DAG->getConstant(1, DL, Int32VT);
+  SDValue MinusOne = DAG->getConstant(APInt(Int32VT.getScalarSizeInBits(), -1, true), DL, Int32VT);
   SDValue AllOnes = DAG->getConstant(APInt::getAllOnes(32), DL, Int32VT);
   SDValue SetCC = DAG->getSetCC(DL, Int32VT, Arg0, Const3, ISD::SETULT);
 
@@ -575,6 +576,21 @@ TEST_F(SelectionDAGPatternMatchTest, matchConstants) {
   EXPECT_TRUE(sd_match(One, DAG.get(), m_True()));
   EXPECT_FALSE(sd_match(AllOnes, DAG.get(), m_True()));
 
+  EXPECT_TRUE (sd_match(MinusOne, DAG.get(), m_Negative()));
+  EXPECT_TRUE (sd_match(MinusOne, DAG.get(), m_NonZero()));
+  EXPECT_TRUE (sd_match(MinusOne, DAG.get(), m_NonPositive()));
+  EXPECT_FALSE(sd_match(MinusOne, DAG.get(), m_StrictlyPositive()));
+
+  EXPECT_FALSE(sd_match(Zero, DAG.get(), m_Negative()));
+  EXPECT_FALSE(sd_match(Zero, DAG.get(), m_NonZero()));
+  EXPECT_TRUE (sd_match(Zero, DAG.get(), m_NonPositive()));
+  EXPECT_FALSE(sd_match(Zero, DAG.get(), m_StrictlyPositive()));
+
+  EXPECT_FALSE(sd_match(One, DAG.get(), m_Negative()));
+  EXPECT_TRUE (sd_match(One, DAG.get(), m_NonZero()));
+  EXPECT_FALSE(sd_match(One, DAG.get(), m_NonPositive()));
+  EXPECT_TRUE (sd_match(One, DAG.get(), m_StrictlyPositive()));
+
   ISD::CondCode CC;
   EXPECT_TRUE(sd_match(
       SetCC, m_Node(ISD::SETCC, m_Value(), m_Value(), m_CondCode(CC))));

RKSimon · 2026-01-09T16:57:52Z

llvm/include/llvm/CodeGen/SDPatternMatch.h

+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNegative(N) : false;


I don't think we need new SelectionDAG helpers for these, try:

Suggested change

return DAG ? DAG->IsNegative(N) : false;

return DAG && DAG->computeKnownBits(N).IsNegative() ;

I was also checking whether the SDValue corresponds to a Scalar Integer or Floating point in the helper functions. Would that be necessary or this would suffice?

Not necessary, we want this to work for vectors as well - computeKnownBits is your friend :)

RKSimon · 2026-01-09T16:58:38Z

llvm/include/llvm/CodeGen/SDPatternMatch.h

+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNonNegative(N) : false;


Suggested change

return DAG ? DAG->IsNonNegative(N) : false;

return DAG && DAG->IsNonNegative(N);

RKSimon · 2026-01-09T16:59:32Z

llvm/include/llvm/CodeGen/SDPatternMatch.h

+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsStrictlyPositive(N) : false;


Suggested change

return DAG ? DAG->IsStrictlyPositive(N) : false;

return DAG && DAG->IsStrictlyPositive(N);

RKSimon · 2026-01-09T17:01:18Z

llvm/include/llvm/CodeGen/SDPatternMatch.h

+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNonPositive(N) : false;


Might need to drop this one - not sure

no you don't - we now have IsNonPositive :)

RKSimon · 2026-01-09T17:01:35Z

llvm/include/llvm/CodeGen/SDPatternMatch.h

+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNonZero(N) : false;


Suggested change

return DAG ? DAG->IsNonZero(N) : false;

return DAG && DAG->IsNonZeroN);

RKSimon · 2026-01-09T17:02:49Z

llvm/include/llvm/CodeGen/SDPatternMatch.h

@@ -1213,6 +1244,21 @@ struct AllOnes_match {
  }
 };

+inline Negative_match m_Negative() {


We need captures for these, I need to be able to do the likes of:

sd_match(N, m_Sub(m_Value(X),m_Negative(m_Value(Y)))

Alright👍

Something like this should work (untested):

template <typename ValTy> inline auto m_Negative(const ValTy &V) { return m_AllOf(m_Negative(), V); }

Something like this should work (untested):

template <typename ValTy> inline auto m_Negative(const ValTy &V) { return m_AllOf(m_Negative(), V); }

Thanks! I had also worked out something similar but couldn't get it to work with Value_match() and Value_bind() both. This worked out great!

RKSimon · 2026-01-09T17:03:21Z

llvm/include/llvm/CodeGen/SelectionDAG.h

+  LLVM_ABI bool IsNonNegative(SDValue Op, unsigned Depth = 0) const;
+
+  /// Return true if Op is non zero
+  LLVM_ABI bool IsNonZero(SDValue Op, unsigned Depth = 0) const;


Drop all these

RKSimon · 2026-01-09T17:03:55Z

llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp

Test with non-constants as well

github-actions · 2026-01-09T17:09:55Z

✅ With the latest revision this PR passed the C/C++ code formatter.

RKSimon · 2026-01-12T10:30:40Z

llvm/include/llvm/CodeGen/SDPatternMatch.h

+  template <typename MatchContext>
+  bool match(const MatchContext &M, SDValue N) const {
+    const SelectionDAG *DAG = M.getDAG();
+    return DAG ? DAG->IsNonPositive(N) : false;


Suggested change

return DAG ? DAG->IsNonPositive(N) : false;

return DAG && DAG->IsNonPositive(N);

…e/m_NonPositive/m_NonZero matchers

ak1932 · 2026-01-13T22:22:35Z

@RKSimon Sorry for the delay, I was a bit caught up with school and internship work, and couldn't devote much time to this issue / PR, the previous week. I have now made the changes requested and also rebased to make use of isNonPositive() helper in KnownBits.

RKSimon

Please can you add a couple of tests case where DAG has not been set inside sd_match - just to ensure that we don't attempt deref a nullptr to DAG

…e/m_NonPositive/m_NonZero matchers

ak1932 · 2026-01-14T16:26:01Z

Also, in the default configuration all tests in SelectionDAGPatternMatchTest were skipped, so I had to change the TargetTriple from aarch64 to x86_64 which is my machine. Should I have committed that as well? I think by default the TargetTriple should probably be fetched from the machine or as the FIXME comment says, should have a skeleton target

llvm-project/llvm/unittests/CodeGen/SelectionDAGTestBase.h

Line 37 in ce6dd8b

Triple TargetTriple("aarch64--");

RKSimon · 2026-01-14T16:48:34Z

what targets are you building in cmake?

ak1932 · 2026-01-14T17:28:25Z

what targets are you building in cmake?

Only X86 with RelWithDebInfo build type

cmake -S llvm -B build -G Ninja -DLLVM_USE_LINKER=lld -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_TARGETS_TO_BUILD=X86 -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_ENABLE_PROJECTS='lld'

RKSimon · 2026-01-14T18:01:20Z

Yes, you will need to add AARCH64 to your LLVM_TARGETS_TO_BUILD list as well - don't change the unit test triple

RKSimon

@ak1932 please can you fix the clang-format CI warning

ak1932 · 2026-01-16T14:13:38Z

@ak1932 please can you fix the clang-format CI warning

I think I have already formatted my code, will check again.

RKSimon · 2026-01-16T14:34:47Z

Take a look at the CI warning

ak1932 · 2026-01-16T16:51:52Z

I checked again, and it did require some formatting 😅 Will pay attention to CI for any issues next time 👍
Thanks!

RKSimon · 2026-01-16T18:08:22Z

llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp

+  SDValue SignBit = DAG->getConstant(0x80000000u, DL, Int32VT);
+  SDValue LSB = DAG->getConstant(0x00000001u, DL, Int32VT);
+  // ~SignBit
+  SDValue NotSignBit = DAG->getNode(


DAG.getNOT?

Oh, right 😅

Probably a silly question; as a code reviewer, do you prefer amending existing commits and force pushing or making new commits?

Extra commits are better - avoid rebase and force push whenever possible to retain comment history

RKSimon · 2026-01-21T22:56:59Z

@ak1932 If you're after a use case in DAGCombine - the HasKnownSameSign lambda inside visitIMINMAX might be a good option

RKSimon

Missing a DAGCombine usage (if we can)

ak1932 · 2026-01-22T12:15:29Z

Yeah, the issue that I faced with finding a fold was that any fold I could think of was already performed using DAG.SignBitIsZero and such variants. I will check the lambda you mentioned 👍

ak1932 · 2026-01-22T12:51:45Z

HasKnownSameSign

    auto HasKnownSameSign = [&](SDValue A, SDValue B) {
      if (A.isUndef() || B.isUndef())
        return true;

      KnownBits KA = DAG.computeKnownBits(A);
      if (!KA.isNonNegative() && !KA.isNegative())
        return false;

      KnownBits KB = DAG.computeKnownBits(B);
      if (KA.isNonNegative())
        return KB.isNonNegative();
      return KB.isNegative();
    };

    if (HasKnownSameSign(N0, N1)) {

Here, HasKnownSameSign lambda uses computeKnownBits once per value. To replace it with the new matchers we would use something like this

    if (sd_match(N, &DAG, m_BinOp(Opcode, m_NonPositive(), m_NonPositive()))
        || sd_match(N, &DAG, m_BinOp(Opcode, m_NonNegative(), m_NonNegative()))) {

However, it would use computeKnownBits twice per value in non negative cases.

RKSimon

LGTM - cheers - we'll add DAG combine coverage as it comes along

llvm-ci · 2026-01-22T14:22:37Z

LLVM Buildbot has detected a new failure on builder libc-x86_64-debian running on libc-x86_64-debian while building llvm at step 2 "update-annotated-scripts".

Full details are available at: https://lab.llvm.org/buildbot/#/builders/43/builds/37312

Here is the relevant piece of the build log for the reference

Step 2 (update-annotated-scripts) failure: update (failure)
git version 2.39.5
remote: Internal Server Error
fatal: unable to access 'https://github.com/llvm/llvm-zorg.git/': The requested URL returned error: 500
remote: Internal Server Error
fatal: unable to access 'https://github.com/llvm/llvm-zorg.git/': The requested URL returned error: 500

…e/m_NonPositive/m_NonZero matchers (llvm#175191) Resolves llvm#174327

llvmbot added the llvm:SelectionDAG SelectionDAGISel as well label Jan 9, 2026

ak1932 marked this pull request as draft January 9, 2026 15:58

RKSimon requested review from RKSimon and mshockwave January 9, 2026 16:56

RKSimon requested changes Jan 9, 2026

View reviewed changes

RKSimon mentioned this pull request Jan 9, 2026

[Support] Add KnownBits::isNonPositive() helper and exhaustive test coverage for isNegative/isNonNegative/isStrictlyPositive/isNonPositive/isNonZero #175203

Closed

RKSimon reviewed Jan 12, 2026

View reviewed changes

[DAG] SDPatternMatch - add m_Negative/m_StrictlyPositive/m_NonNegativ…

fbd8f4b

…e/m_NonPositive/m_NonZero matchers

ak1932 force-pushed the DAG_matchers branch from 95549a8 to f999307 Compare January 13, 2026 21:24

ak1932 requested a review from RKSimon January 13, 2026 22:21

RKSimon marked this pull request as ready for review January 14, 2026 14:56

RKSimon requested changes Jan 14, 2026

View reviewed changes

ak1932 force-pushed the DAG_matchers branch 3 times, most recently from 67903a8 to cfb843b Compare January 14, 2026 16:11

[DAG] Add Unit testing for m_Negative/m_StrictlyPositive/m_NonNegativ…

3a3db11

…e/m_NonPositive/m_NonZero matchers

ak1932 force-pushed the DAG_matchers branch from cfb843b to 3a3db11 Compare January 14, 2026 16:14

RKSimon requested changes Jan 16, 2026

View reviewed changes

[DAG] Formatting for SelectionDAGPatternMatchTest

a032dbe

RKSimon self-requested a review January 16, 2026 18:06

RKSimon reviewed Jan 16, 2026

View reviewed changes

[DAG] Refactor SelectionDAGPatternMatchTest

02ce29f

RKSimon self-requested a review January 21, 2026 21:29

RKSimon requested changes Jan 22, 2026

View reviewed changes

RKSimon approved these changes Jan 22, 2026

View reviewed changes

Merge branch 'main' into DAG_matchers

f930373

RKSimon enabled auto-merge (squash) January 22, 2026 13:41

RKSimon merged commit af4f5ee into llvm:main Jan 22, 2026
10 of 11 checks passed

Harrish92 pushed a commit to Harrish92/llvm-project that referenced this pull request Jan 23, 2026

[DAG] SDPatternMatch - add m_Negative/m_StrictlyPositive/m_NonNegativ…

a7a9938

…e/m_NonPositive/m_NonZero matchers (llvm#175191) Resolves llvm#174327

Harrish92 pushed a commit to Harrish92/llvm-project that referenced this pull request Jan 24, 2026

[DAG] SDPatternMatch - add m_Negative/m_StrictlyPositive/m_NonNegativ…

10037c5

…e/m_NonPositive/m_NonZero matchers (llvm#175191) Resolves llvm#174327

	return DAG ? DAG->IsNegative(N) : false;
	return DAG && DAG->computeKnownBits(N).IsNegative() ;

	return DAG ? DAG->IsNonNegative(N) : false;
	return DAG && DAG->IsNonNegative(N);

	return DAG ? DAG->IsStrictlyPositive(N) : false;
	return DAG && DAG->IsStrictlyPositive(N);

	return DAG ? DAG->IsNonZero(N) : false;
	return DAG && DAG->IsNonZeroN);

	return DAG ? DAG->IsNonPositive(N) : false;
	return DAG && DAG->IsNonPositive(N);

Conversation

ak1932 commented Jan 9, 2026

Uh oh!

github-actions bot commented Jan 9, 2026

Uh oh!

ak1932 commented Jan 9, 2026

Uh oh!

llvmbot commented Jan 9, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

github-actions bot commented Jan 9, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

RKSimon Jan 12, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ak1932 commented Jan 13, 2026

Uh oh!

RKSimon left a comment

Choose a reason for hiding this comment

Uh oh!

ak1932 commented Jan 14, 2026

Uh oh!

RKSimon commented Jan 14, 2026

Uh oh!

ak1932 commented Jan 14, 2026

Uh oh!

RKSimon commented Jan 14, 2026

Uh oh!

RKSimon left a comment

Choose a reason for hiding this comment

Uh oh!

ak1932 commented Jan 16, 2026

Uh oh!

RKSimon commented Jan 16, 2026

Uh oh!

ak1932 commented Jan 16, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

RKSimon commented Jan 21, 2026

Uh oh!

github-actions bot commented Jan 9, 2026 •

edited

Loading

RKSimon Jan 12, 2026 •

edited

Loading

ak1932 commented Jan 22, 2026 •

edited

Loading