[InstCombine] Fold Xor with or disjoint #105992

AmrDeveloper · 2024-08-25T15:58:36Z

Implement a missing optimization fold (X | Y) ^ M to (X ^ M) ^ Y and (X | Y) ^ M to (Y ^ M) ^ X

llvmbot · 2024-08-25T15:59:07Z

@llvm/pr-subscribers-llvm-transforms

Author: Amr Hesham (AmrDeveloper)

Changes

Implement a missing optimization fold from ((select C1, C2) | A) ^ C3) to be ((Select C1 ^ C3, C2 ^ C3) | A)

Fixes: #79266

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

2 Files Affected:

(modified) llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp (+22)
(added) llvm/test/Transforms/InstCombine/disjoint_or.ll (+32)

diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
index b703bc7d04db58..59bd133e56b118 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
@@ -4056,6 +4056,25 @@ Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
   return nullptr;
 }
 
+static Instruction *foldXorToOr(BinaryOperator &I,
+                                InstCombiner::BuilderTy &Builder) {
+  assert(I.getOpcode() == Instruction::Xor);
+  Value *A, *B, *C, *D, *E;
+
+  // ((select C, A, B) | E) ^ D) -> (select C, A ^ D, B ^ D) | E)
+  if (match(&I,
+            m_c_Xor(m_c_DisjointOr(m_Select(m_Value(C), m_Value(A), m_Value(B)),
+                                   m_Value(E)),
+                    m_Value(D)))) {
+    Value *XorAB = Builder.CreateXor(A, D);
+    Value *XorBD = Builder.CreateXor(B, D);
+    Value *S = Builder.CreateSelect(C, XorAB, XorBD);
+    return BinaryOperator::CreateDisjointOr(S, E);
+  }
+
+  return nullptr;
+}
+
 /// A ^ B can be specified using other logic ops in a variety of patterns. We
 /// can fold these early and efficiently by morphing an existing instruction.
 static Instruction *foldXorToXor(BinaryOperator &I,
@@ -4658,6 +4677,9 @@ Instruction *InstCombinerImpl::visitXor(BinaryOperator &I) {
   if (Instruction *NewXor = foldXorToXor(I, Builder))
     return NewXor;
 
+  if (Instruction *NewOr = foldXorToOr(I, Builder))
+    return NewOr;
+
   // (A&B)^(A&C) -> A&(B^C) etc
   if (Value *V = foldUsingDistributiveLaws(I))
     return replaceInstUsesWith(I, V);
diff --git a/llvm/test/Transforms/InstCombine/disjoint_or.ll b/llvm/test/Transforms/InstCombine/disjoint_or.ll
new file mode 100644
index 00000000000000..81fa4c33199fd4
--- /dev/null
+++ b/llvm/test/Transforms/InstCombine/disjoint_or.ll
@@ -0,0 +1,32 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+
+define i32 @fold_xor_with_disjoint_or(i32 %a, i1 %c) {
+; CHECK-LABEL: define i32 @fold_xor_with_disjoint_or(
+; CHECK-SAME: i32 [[A:%.*]], i1 [[C:%.*]]) {
+; CHECK-NEXT:    [[SHL:%.*]] = shl i32 [[A]], 4
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[C]], i32 4, i32 0
+; CHECK-NEXT:    [[XOR:%.*]] = or disjoint i32 [[TMP1]], [[SHL]]
+; CHECK-NEXT:    ret i32 [[XOR]]
+;
+  %s = select i1 %c, i32 0, i32 4
+  %shl = shl i32 %a, 4
+  %or = or disjoint i32 %s, %shl
+  %xor = xor i32 %or, 4
+  ret i32 %xor
+}
+
+define <2 x i32> @fold_xor_with_disjoint_or_vec(<2 x i32> %a, i1 %c) {
+; CHECK-LABEL: define <2 x i32> @fold_xor_with_disjoint_or_vec(
+; CHECK-SAME: <2 x i32> [[A:%.*]], i1 [[C:%.*]]) {
+; CHECK-NEXT:    [[SHL:%.*]] = shl <2 x i32> [[A]], <i32 4, i32 4>
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[C]], <2 x i32> <i32 4, i32 4>, <2 x i32> zeroinitializer
+; CHECK-NEXT:    [[XOR:%.*]] = or disjoint <2 x i32> [[TMP1]], [[SHL]]
+; CHECK-NEXT:    ret <2 x i32> [[XOR]]
+;
+  %s = select i1 %c, <2 x i32> <i32 0, i32 0>, <2 x i32> <i32 4, i32 4>
+  %shl = shl <2 x i32> %a, <i32 4, i32 4>
+  %or = or disjoint <2 x i32> %s, %shl
+  %xor = xor <2 x i32> %or, <i32 4, i32 4>
+  ret <2 x i32> %xor
+}

elhewaty · 2024-08-25T19:49:33Z

llvm/test/Transforms/InstCombine/disjoint_or.ll

@@ -0,0 +1,32 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+


I believe you should place the tests in the xor.ll.

elhewaty · 2024-08-25T19:51:27Z

llvm/test/Transforms/InstCombine/disjoint_or.ll

+  %or = or disjoint <2 x i32> %s, %shl
+  %xor = xor <2 x i32> %or, <i32 4, i32 4>
+  ret <2 x i32> %xor
+}


we need more test cases e.g., negative tests, one use, more than one use case, etc...

Also, we need test cases for commutative operations (or and xor) to see if the optimization works when the LHS and RHS are shuffled.
hmm, I think we need only for or as it has a non-const operand A, but we don't need for xor as the canonicalizer always places constants on the right-hand side.

elhewaty · 2024-08-25T20:05:38Z

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

+  Value *A, *B, *C, *D, *E;
+
+  // ((select C, A, B) | E) ^ D) -> (select C, A ^ D, B ^ D) | E)
+  if (match(&I,


move this condition to the InstCombinerImpl::visitXor function.
I can help with the condition, but I let you think.
further hints:
I think I should refer to @dtcxzyw to double-check my suggestions:

I think the issue was about matching constants in place of A, B, and D, so It's better to use m_APInt instead.

Will this check be profitable if the or has more than one use? 🤔

Will this check be profitable if the or has more than one use? 🤔

Probably not.

XChy · 2024-08-26T15:20:33Z

It's my fault for not providing generalized proof of the issue, but I don't think your pattern here is correct.
IIUC, you try to fold (A | B) ^ C into (A ^ C) | B iff A ^ C can be simplified, but it's wrong:
https://alive2.llvm.org/ce/z/s7VV8u
The correct pattern should be (A | B) ^ C --> (A ^ C) ^ B: https://alive2.llvm.org/ce/z/u2vco3
The key is to treat or disjoint as xor.

AmrDeveloper · 2024-08-26T20:08:13Z

It's my fault for not providing generalized proof of the issue, but I don't think your pattern here is correct. IIUC, you try to fold (A | B) ^ C into (A ^ C) | B iff A ^ C can be simplified, but it's wrong: https://alive2.llvm.org/ce/z/s7VV8u The correct pattern should be (A | B) ^ C --> (A ^ C) ^ B: https://alive2.llvm.org/ce/z/u2vco3 The key is to treat or disjoint as xor.

Thank you, i change the pattern, test code ...etc

elhewaty · 2024-08-27T14:36:44Z

The correct pattern should be (A | B) ^ C --> (A ^ C) ^ B: https://alive2.llvm.org/ce/z/u2vco3
The key is to treat or disjoint as xor.

Is this optimization profitable? We still have the same number of instructions, I think it depends on the target architecture if it has a special handling or if the pipelining prefers XOR.

this is just a guess.

XChy · 2024-08-27T14:45:45Z

The correct pattern should be (A | B) ^ C --> (A ^ C) ^ B: https://alive2.llvm.org/ce/z/u2vco3
The key is to treat or disjoint as xor.

Is this optimization profitable? We still have the same number of instructions, I think it depends on the target architecture if it has a special handling or if the pipelining prefers XOR.

this is just a guess.

This fold is profitable if A ^ C folds. ((select C1, C2) | A) ^ C3 --> (select C1^C3, C2^C3) | A) is just a specific case.

elhewaty

this is a great work, thanks.

elhewaty · 2024-08-29T21:41:13Z

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

@@ -4706,6 +4706,13 @@ Instruction *InstCombinerImpl::visitXor(BinaryOperator &I) {
    return Xor;

  Value *X, *Y;
+
+  // (A | B) ^ C -> (A ^ C) ^ B
+  if (match(Op0, m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))))) {


I don't think this will handle C ^ (A | B)!

Suggested change

if (match(Op0, m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))))) {

if (match(&I, m_c_Xor(m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))), m_Value(M)))) {

There's an M variable declared above if this is confusing you can declare a variable *Z in the if clause

if (Value *Z; ...)

Thanks for suggestion, i used M

elhewaty · 2024-08-29T21:43:37Z

llvm/test/Transforms/InstCombine/xor.ll

-; CHECK-NEXT:    [[OR:%.*]] = or disjoint <2 x i32> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[XOR:%.*]] = xor <2 x i32> [[OR]], [[C:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = xor <2 x i32> [[A:%.*]], [[C:%.*]]
+; CHECK-NEXT:    [[XOR:%.*]] = xor <2 x i32> [[TMP0]], [[B:%.*]]
 ; CHECK-NEXT:    ret <2 x i32> [[XOR]]
 ;
 entry:


Can you please add more negative test cases?
you are using m_OneUse we should have a test to check if this works as expected.
and a test for the C ^ (A | B) case.

github-actions · 2024-08-30T17:44:25Z

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

dtcxzyw

Can you add some tests to demonstrate the usefulness of this patch (e.g., the original issue #79266)?

AmrDeveloper · 2024-09-01T07:33:00Z

Can you add some tests to demonstrate the usefulness of this patch (e.g., the original issue #79266)?

Done

AmrDeveloper · 2024-09-01T12:52:56Z

Can you add some tests to demonstrate the usefulness of this patch (e.g., the original issue #79266)?

Any idea why it timeout on ninja runtimes C++03 on linux CI, i did rebase to the code but still same issue

goldsteinn · 2024-09-01T18:51:03Z

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

+                        m_Value(M)))) {
+    Value *XorAC = Builder.CreateXor(X, M);
+    return BinaryOperator::CreateXor(XorAC, Y);
+  }


Is this desirable? I'd say disjoint or is preferable to an xor in most if not all respects.

I would limit this if X ^ M folds. You can test it with:
if (Value * XorAC = simplifyBinOp(Instruction::Xor, X, M, SQ)

You could also try if Y, M simplify.

So can we do

if X ^ M folds -> (X ^ M) ^ Y

if Y ^ M folds -> (Y ^ M) ^ X

Now i checked simplify and update samples, this is alive2 for current test depending that A ^ M will folded

https://alive2.llvm.org/ce/z/NLhfhN

With simplifyBinOp, it could not handle the motivating case anymore. @dtcxzyw, could you test the impact of this patch? If it optimizes other cases still, I wouldn't argue about it.

An unrelated idea occurred to me: could we rank select cond, C1, C2 with the same number as constants in the Reassociate pass?

goldsteinn · 2024-09-01T18:54:34Z

Can you add some tests to demonstrate the usefulness of this patch (e.g., the original issue #79266)?

Any idea why it timeout on ninja runtimes C++03 on linux CI, i did rebase to the code but still same issue

Probably an inf loop. Typically we do xor -> disjoint or. If the three value all dont share bits I think this will inf loop between (xor (or disjoint x, y), z) -> (xor (xor x, z), y)

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

AmrDeveloper · 2024-09-04T10:01:11Z

Can you add some tests to demonstrate the usefulness of this patch (e.g., the original issue #79266)?

Any idea why it timeout on ninja runtimes C++03 on linux CI, i did rebase to the code but still same issue

Probably an inf loop. Typically we do xor -> disjoint or. If the three value all dont share bits I think this will inf loop between (xor (or disjoint x, y), z) -> (xor (xor x, z), y)

Yes it passed now

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

PR Link: llvm/llvm-project#105992

AmrDeveloper · 2024-09-15T16:20:37Z

Any updates for this PR review @XChy, @goldsteinn, @dtcxzyw?

goldsteinn · 2024-09-16T13:59:04Z

LGTM

AmrDeveloper · 2024-09-16T17:39:59Z

LGTM

Thank you, you can accpet it :D, once other accepted we can merge

AmrDeveloper · 2024-09-18T16:06:13Z

@nikic Can you check this PR when you have time

nikic

Looks reasonable.

A possible alternative would be to try to integrate this inside SimplifyAssociativeOrCommutative, by replacing the opcode == matches there with a stronger check that knows that or disjoint is compatible with or, xor and add. I'm okay with the separate fold though.

nikic · 2024-09-22T08:24:23Z

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

+
+  // (A | B) ^ C -> (A ^ C) ^ B
+  // C ^ (A | B) -> B ^ (A ^ C)
+  if (match(&I, m_c_Xor(m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))),


Suggested change

if (match(&I, m_c_Xor(m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))),

if (match(&I, m_c_Xor(m_OneUse(m_DisjointOr(m_Value(X), m_Value(Y))),

Commutative matcher doesn't make sense if you are only capturing values.

nikic · 2024-09-22T08:25:43Z

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

+  // (A | B) ^ C -> (A ^ C) ^ B
+  // C ^ (A | B) -> B ^ (A ^ C)


Suggested change

// (A | B) ^ C -> (A ^ C) ^ B

// C ^ (A | B) -> B ^ (A ^ C)

// (X | Y) ^ M -> (X ^ M) ^ Y

// (X | Y) ^ M -> (Y ^ M) ^ X

Try to use the same names as in the code to make it easier to compare.

nikic · 2024-09-22T08:26:20Z

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

+  // C ^ (A | B) -> B ^ (A ^ C)
+  if (match(&I, m_c_Xor(m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))),
+                        m_Value(M)))) {
+    if (Value *XorAC = simplifyBinOp(Instruction::Xor, X, M, SQ))


Suggested change

if (Value *XorAC = simplifyBinOp(Instruction::Xor, X, M, SQ))

if (Value *XorAC = simplifyBinOp(Instruction::Xor, X, M, SQ.getWithInstruction(&I)))

nikic · 2024-09-22T08:27:38Z

llvm/test/Transforms/InstCombine/xor.ll

+; CHECK-NEXT:    ret i32 [[B:%.*]]
+;
+entry:
+  %or = or disjoint i32 %a, %b


Should also have a commuted variant with %b, %a, if I didn't miss is somewhere.

nikic · 2024-09-22T08:27:47Z

llvm/test/Transforms/InstCombine/xor.ll

+  ret i32 %xor
+}
+
+define i32 @xor_with_or_disjoint(i32 %a, i32 %b, i32 %c) {


Unused argument %c.

Implement a missing optimization to fold (A | B) ^ C to (A ^ C) ^ B

nikic · 2024-09-22T10:26:30Z

Fixes: #79266

Fixes -> "Related to" or something? I don't think this PR fixes that issue as-is.

nikic

LGTM

nikic · 2024-09-22T10:27:15Z

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

+  if (match(&I, m_c_Xor(m_OneUse(m_DisjointOr(m_Value(X), m_Value(Y))),
+                        m_Value(M)))) {
+    if (Value *XorAC =
+            simplifyBinOp(Instruction::Xor, X, M, SQ.getWithInstruction(&I)))


Suggested change

simplifyBinOp(Instruction::Xor, X, M, SQ.getWithInstruction(&I)))

simplifyXorInst(X, M, SQ.getWithInstruction(&I)))

nikic · 2024-09-22T10:27:35Z

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

+            simplifyBinOp(Instruction::Xor, X, M, SQ.getWithInstruction(&I)))
+      return BinaryOperator::CreateXor(XorAC, Y);
+
+    if (Value *XorBC = simplifyBinOp(Instruction::Xor, Y, M, SQ))


Suggested change

if (Value *XorBC = simplifyBinOp(Instruction::Xor, Y, M, SQ))

if (Value *XorBC = simplifyXorInst(Y, M, SQ.getWithInstruction(&I)))

AmrDeveloper · 2024-09-22T10:30:19Z

Fixes: #79266

Fixes -> "Related to" or something? I don't think this PR fixes that issue as-is.

Yes we changed the case, i will remove issue mention and describe the current fix

Thank you

Followup to #105992, use the simplifyXorInst helper and use getWithInstruction consistently.

AmrDeveloper requested a review from nikic as a code owner August 25, 2024 15:58

llvmbot added the llvm:transforms label Aug 25, 2024

AmrDeveloper force-pushed the instcom_optimize_fold branch from 7c579c8 to edd78ee Compare August 25, 2024 16:47

nikic requested a review from dtcxzyw August 25, 2024 19:05

elhewaty reviewed Aug 25, 2024

View reviewed changes

dtcxzyw requested a review from goldsteinn August 26, 2024 06:10

AmrDeveloper force-pushed the instcom_optimize_fold branch from edd78ee to 9742ec2 Compare August 29, 2024 19:40

elhewaty reviewed Aug 29, 2024

View reviewed changes

AmrDeveloper force-pushed the instcom_optimize_fold branch 2 times, most recently from 9d1106e to b2ecae0 Compare August 30, 2024 17:40

AmrDeveloper force-pushed the instcom_optimize_fold branch 2 times, most recently from 639dd85 to 48c88e6 Compare August 31, 2024 06:20

dtcxzyw reviewed Sep 1, 2024

View reviewed changes

AmrDeveloper force-pushed the instcom_optimize_fold branch from 48c88e6 to 2c2bdda Compare September 1, 2024 07:31

goldsteinn reviewed Sep 1, 2024

View reviewed changes

AmrDeveloper force-pushed the instcom_optimize_fold branch from 2c2bdda to f89cd57 Compare September 2, 2024 17:29

elhewaty reviewed Sep 2, 2024

View reviewed changes

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp Outdated Show resolved Hide resolved

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp Outdated Show resolved Hide resolved

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp Outdated Show resolved Hide resolved

[InstCombine] Add pre-commit tests

32c42b7

AmrDeveloper force-pushed the instcom_optimize_fold branch from f89cd57 to f16a121 Compare September 2, 2024 19:14

XChy reviewed Sep 4, 2024

View reviewed changes

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp Outdated Show resolved Hide resolved

AmrDeveloper force-pushed the instcom_optimize_fold branch from f16a121 to f6c06b9 Compare September 4, 2024 19:45

AmrDeveloper requested review from goldsteinn, XChy and dtcxzyw September 5, 2024 21:21

dtcxzyw added a commit to dtcxzyw/llvm-opt-benchmark that referenced this pull request Sep 8, 2024

pre-commit: test PR105992

bd70460

PR Link: llvm/llvm-project#105992

dtcxzyw mentioned this pull request Sep 8, 2024

pre-commit: test PR105992 dtcxzyw/llvm-opt-benchmark#1284

Closed

nikic reviewed Sep 22, 2024

View reviewed changes

[InstCombine] Fold Xor with or disjoint

7107113

Implement a missing optimization to fold (A | B) ^ C to (A ^ C) ^ B

AmrDeveloper force-pushed the instcom_optimize_fold branch from f6c06b9 to 7107113 Compare September 22, 2024 08:53

AmrDeveloper requested a review from nikic September 22, 2024 10:20

nikic approved these changes Sep 22, 2024

View reviewed changes

AmrDeveloper merged commit 9614f69 into llvm:main Sep 22, 2024
8 checks passed

nikic added a commit that referenced this pull request Sep 23, 2024

[InstCombine] Fix nits in new xor fold

7a18198

Followup to #105992, use the simplifyXorInst helper and use getWithInstruction consistently.

		@@ -0,0 +1,32 @@
		; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
		; RUN: opt < %s -passes=instcombine -S \| FileCheck %s

	if (match(Op0, m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))))) {
	if (match(&I, m_c_Xor(m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))), m_Value(M)))) {

	if (match(&I, m_c_Xor(m_OneUse(m_c_DisjointOr(m_Value(X), m_Value(Y))),
	if (match(&I, m_c_Xor(m_OneUse(m_DisjointOr(m_Value(X), m_Value(Y))),

	if (Value *XorAC = simplifyBinOp(Instruction::Xor, X, M, SQ))
	if (Value *XorAC = simplifyBinOp(Instruction::Xor, X, M, SQ.getWithInstruction(&I)))

	simplifyBinOp(Instruction::Xor, X, M, SQ.getWithInstruction(&I)))
	simplifyXorInst(X, M, SQ.getWithInstruction(&I)))

	if (Value *XorBC = simplifyBinOp(Instruction::Xor, Y, M, SQ))
	if (Value *XorBC = simplifyXorInst(Y, M, SQ.getWithInstruction(&I)))

[InstCombine] Fold Xor with or disjoint #105992

[InstCombine] Fold Xor with or disjoint #105992

Uh oh!

Conversation

AmrDeveloper commented Aug 25, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

llvmbot commented Aug 25, 2024

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!

XChy commented Aug 26, 2024

Uh oh!

AmrDeveloper commented Aug 26, 2024

Uh oh!

elhewaty commented Aug 27, 2024

Uh oh!

XChy commented Aug 27, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

elhewaty left a comment

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 Aug 30, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

dtcxzyw left a comment

Choose a reason for hiding this comment

Uh oh!

AmrDeveloper commented Sep 1, 2024

Uh oh!

AmrDeveloper commented Sep 1, 2024

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AmrDeveloper Sep 1, 2024 • 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!

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!

goldsteinn commented Sep 1, 2024

Uh oh!

Uh oh!

Uh oh!

Uh oh!

AmrDeveloper commented Sep 4, 2024

Uh oh!

Uh oh!

AmrDeveloper commented Sep 15, 2024

Uh oh!

goldsteinn commented Sep 16, 2024

Uh oh!

AmrDeveloper commented Sep 16, 2024

Uh oh!

AmrDeveloper commented Sep 18, 2024

AmrDeveloper commented Aug 25, 2024 •

edited

Loading

XChy commented Aug 27, 2024 •

edited

Loading

github-actions bot commented Aug 30, 2024 •

edited

Loading

AmrDeveloper Sep 1, 2024 •

edited

Loading