[spirv] Add CompositeExtractOp operation. #44

denis0x0D · 2019-07-09T14:24:03Z

Hello, this patch is addressing #42 issue.

Mostly all verifying checks are added to parser, for some reasons:

To get the result type of operation, we have to iterate all over the indices, seems like the better way to do it once, instead two times in parser and verifier.
To get the element type of the struct type we have to access it by index, to make it save the check for out of bounds access must be added and it seems like the better way do it once only in the parser.

BTW, I might miss something and do not see the possible side effects of this, please fix me if I'm wrong.

The verifier only checks that extracted type is not the same as composite type, to handle situation like this
%0 = spv.CompositeExtract %arg0[] : !spv.array<4x!spv.array<4xf32>>

The tests for different composite types added, also StructType is added to composite and spirv types.

@antiagainst can you please take a look. Thanks!

antiagainst

This is awesome, thanks denis0x0D! I like the extensive tests! :)

Yes because we need to set the extracted component's type, we need to duplicate the check that happens in the validator inside the parser. It's a bit annoying. The parser check is only used for parsing custom assembly forms; the verifier guards all paths: parsing custom assembly form, parsing generic assembly form, and building ops with C++ API, etc. So we need both. But by properly define them with functions I think we can share the same impl at least.

More comments inline.

antiagainst · 2019-07-09T15:15:29Z

include/mlir/SPIRV/SPIRVBase.td

@@ -79,14 +80,15 @@ def SPV_Vector : VectorOf<[SPV_Bool, SPV_Integer, SPV_Float]>;
 def SPV_AnyPtr : Type<SPV_IsPtrType, "any SPIR-V pointer type">;
 def SPV_AnyArray : Type<SPV_IsArrayType, "any SPIR-V array type">;
 def SPV_AnyRTArray : Type<SPV_IsRTArrayType, "any SPIR-V runtime array type">;
+def SPV_AnyStruct : Type<SPV_IsStructType, "any SPIR-V struct type">;

 def SPV_Numerical : AnyTypeOf<[SPV_Integer, SPV_Float]>;
 def SPV_Scalar : AnyTypeOf<[SPV_Numerical, SPV_Bool]>;
 def SPV_Aggregrate : AnyTypeOf<[SPV_AnyArray]>;


We should also add SPV_AnyStruct to SPV_Aggregrate.

Thanks, added.

antiagainst · 2019-07-09T15:16:23Z

include/mlir/SPIRV/SPIRVOps.td

+  let summary = "Extract a part of a composite object.";
+
+  let description = [{
+    Extract a part of a composite object.


No need to duplicate the summary line. The summary and description will be concatenated together when generating the doc.

antiagainst · 2019-07-09T15:18:16Z

include/mlir/SPIRV/SPIRVOps.td

+    I32ArrayAttr:$indices
+  );
+
+  let results = (outs SPV_Type);


Please give the output a name, like $component or something so that we will generate a nicer getter method for ti. :)

antiagainst · 2019-07-09T15:19:13Z

lib/SPIRV/SPIRVOps.cpp

@@ -740,6 +740,102 @@ static LogicalResult verify(spirv::VariableOp varOp) {
  return success();
 }

+//===----------------------------------------------------------------------===//
+// spv.CompositeExtractOp


Nit: Ops should be sorted alphabetically in this file.

Oh, I see, thanks, fixed.

antiagainst · 2019-07-09T15:36:44Z

lib/SPIRV/SPIRVOps.cpp

+
+// Extracts the Result Type from Composite Type iterating all over the indices,
+// with check for out of bounds.
+static Type getElementTypeByIndices(OpAsmParser *parser, OperationState *state,


I think this element type extraction logic is generally useful for working with composite types. So it should be added to the type system. We can create a base class for composite types and let struct and arrays subclass from it. That way we have a uniform interface for querying element types. This involves touching custom types registered for the SPIR-V dialect though. You can use ShapedType and VectorType as an example of how to define base class and subclasses:

mlir/include/mlir/IR/StandardTypes.h

Lines 178 to 272 in 9422eb7

/// This is a common base class between Vector, UnrankedTensor, RankedTensor,

/// and MemRef types because they share behavior and semantics around shape,

/// rank, and fixed element type. Any type with these semantics should inherit

/// from ShapedType.

class ShapedType : public Type {

public:

using ImplType = detail::ShapedTypeStorage;

using Type::Type;

/// Return the element type.

Type getElementType() const;

/// If an element type is an integer or a float, return its width. Otherwise,

/// abort.

unsigned getElementTypeBitWidth() const;

/// If this is a ranked type, return the number of elements. Otherwise, abort.

int64_t getNumElements() const;

/// If this is a ranked type, return the rank. Otherwise, abort.

int64_t getRank() const;

/// Whether or not this is a ranked type. Memrefs, vectors and ranked tensors

/// have a rank, while unranked tensors do not.

bool hasRank() const;

/// If this is a ranked type, return the shape. Otherwise, abort.

ArrayRef<int64_t> getShape() const;

/// If this is unranked type or any dimension has unknown size (<0), it

/// doesn't have static shape. If all dimensions have known size (>= 0), it

/// has static shape.

bool hasStaticShape() const;

/// If this is a ranked type, return the number of dimensions with dynamic

/// size. Otherwise, abort.

int64_t getNumDynamicDims() const;

/// If this is ranked type, return the size of the specified dimension.

/// Otherwise, abort.

int64_t getDimSize(int64_t i) const;

/// Get the total amount of bits occupied by a value of this type. This does

/// not take into account any memory layout or widening constraints, e.g. a

/// vector<3xi57> is reported to occupy 3x57=171 bit, even though in practice

/// it will likely be stored as in a 4xi64 vector register. Fail an assertion

/// if the size cannot be computed statically, i.e. if the type has a dynamic

/// shape or if its elemental type does not have a known bit width.

int64_t getSizeInBits() const;

/// Methods for support type inquiry through isa, cast, and dyn_cast.

static bool classof(Type type) {

return type.getKind() == StandardTypes::Vector ||

type.getKind() == StandardTypes::RankedTensor ||

type.getKind() == StandardTypes::UnrankedTensor ||

type.getKind() == StandardTypes::MemRef;

}

/// Whether the given dimension size indicates a dynamic dimension.

static constexpr bool isDynamic(int64_t dSize) { return dSize < 0; }

};

/// Vector types represent multi-dimensional SIMD vectors, and have a fixed

/// known constant shape with one or more dimension.

class VectorType

: public Type::TypeBase<VectorType, ShapedType, detail::VectorTypeStorage> {

public:

using Base::Base;

/// Get or create a new VectorType of the provided shape and element type.

/// Assumes the arguments define a well-formed VectorType.

static VectorType get(ArrayRef<int64_t> shape, Type elementType);

/// Get or create a new VectorType of the provided shape and element type

/// declared at the given, potentially unknown, location. If the VectorType

/// defined by the arguments would be ill-formed, emit errors and return

/// nullptr-wrapping type.

static VectorType getChecked(ArrayRef<int64_t> shape, Type elementType,

Location location);

/// Verify the construction of a vector type.

static LogicalResult

verifyConstructionInvariants(llvm::Optional<Location> loc,

MLIRContext *context, ArrayRef<int64_t> shape,

Type elementType);

/// Returns true of the given type can be used as an element of a vector type.

/// In particular, vectors can consist of integer or float primitives.

static bool isValidElementType(Type t) { return t.isIntOrFloat(); }

ArrayRef<int64_t> getShape() const;

/// Methods for support type inquiry through isa, cast, and dyn_cast.

static bool kindof(unsigned kind) { return kind == StandardTypes::Vector; }

};

(VectorType will be tricky given that we cannot directly modify it... But I think we can switch case for it in composite type.)

Please feel free to leave a TODO here if you'd like to defer the change in a subsequent CL or leaving it to me. :)

I've added CompositeType as a base class between ArrayType, StructType. The CompositeTypeStorage does not have a static "construct" method, because we don't need to directly construct it and therefore it does not have a operator == for the hash function.
It provides a method getElementTypByIndices which consumes array of int32_t, as result it returns a pair<Type, StringRef> on success it would be a type selected by the last provided index, on failure a nullpr with an error message. I didn't come with better idea, how to handle different error messages and don't insert asserts.

antiagainst · 2019-07-09T16:02:07Z

lib/SPIRV/SPIRVOps.cpp

+static LogicalResult verify(spirv::CompositeExtractOp compositeExtractOp) {
+  auto resultType = compositeExtractOp.getType();
+  if (resultType == compositeExtractOp.composite()->getType()) {
+    return compositeExtractOp.emitOpError(


Could you still call the function to verify the result type agree with the extracted type? It's a bit unfortunate that we are duplicating the check logic but we need that in the parser to properly set the result type. And this verifier is used across all paths (parsing custom assembly form, parsing generic assembly form, and building ops with C++ API, etc.) so it would be nice to guarantee.

Added a verifier.

antiagainst · 2019-07-09T16:04:00Z

test/SPIRV/ops.mlir

@@ -496,3 +496,139 @@ func @cannot_be_generic_storage_class(%arg0: f32) -> () {
  %0 = spv.Variable : !spv.ptr<f32, Generic>
  return
 }
+
+// -----


Awesome tests! :D

antiagainst · 2019-07-09T16:08:11Z

test/SPIRV/ops.mlir

+
+func @composite_extract_invalid_extracted_type(%arg0: !spv.array<4x!spv.array<4xf32>>) -> () {
+  // expected-error @+1 {{extracted element type can not be the same with composite type}}
+  %0 = spv.CompositeExtract %arg0[] : !spv.array<4x!spv.array<4xf32>>


Ah, it's interesting. I think we need a different check for this. OpCompositeExtract should not allow empty indices. (Although it's not clearly written on the spec.)

Thanks, fixed.

antiagainst · 2019-07-09T16:11:49Z

lib/SPIRV/SPIRVOps.cpp

+  Type resultType = compositeType;
+  for (Attribute indexAttr : indicesArrayAttr) {
+    if (!resultType) {
+      parser->emitError(attrLocation, "invalid type to extract from");


What about ..., "cannnot index into ") << resultType;?

Thanks, added in some cases, but in this case seems like resultType == nullptr.

antiagainst · 2019-07-09T16:15:50Z

lib/SPIRV/SPIRVOps.cpp

+      parser->emitError(attrLocation, "invalid type to extract from");
+      return nullptr;
+    }
+    // The type cast is save, because of the description in TableGen.


This is not true here... The TableGen'd checks are inside verify() but this one is used for parsing.

Thanks, got it, updated.

denis0x0D · 2019-07-09T16:54:42Z

@antiagainst thanks a lot for the detailed review! I'll update it, regarding to your comments.

denis0x0D · 2019-07-11T14:21:23Z

@antiagainst I've updated the patch, regarding your comments, can you please take a look.
Thanks.

antiagainst

Awesome, almost there, just some final comments. Thanks again, Denis!

antiagainst · 2019-07-11T16:27:48Z

include/mlir/SPIRV/SPIRVTypes.h

+  using Type::Type;
+
+  static bool kindof(unsigned kind) {
+    return (kind == TypeKind::Array || kind == TypeKind::Struct);


... || kind == StandardTypes::Vector)

Oh, I see, to be able to use kinda "cast" thing we have to provide "kindof" function. I was stuck for I a while trying to understand how to use Vector from Standard Types as kinda CompositeType, in case we can't directly modify it. Thanks a lot, now I'm understanding MLIR's type system more better. Sorry, for this kind of realization.

antiagainst · 2019-07-11T17:56:28Z

lib/SPIRV/SPIRVOps.cpp

+
+  if (!indicesArrayAttr.size()) {
+    return parser->emitError(attrLocation, "expexted at least one index for ")
+           << compositeType;


You mean spv.CompositeExtract here?

Thanks, updated.

antiagainst · 2019-07-11T17:58:11Z

lib/SPIRV/SPIRVOps.cpp

+      indexes.push_back(indexIntAttr.getInt());
+    } else {
+      return parser->emitError(attrLocation,
+                               "expexted an 32-bit integer for index");


... but found '") << indexAttr << "'";

antiagainst · 2019-07-11T18:01:25Z

lib/SPIRV/SPIRVOps.cpp

+
+  if (!indicesArrayAttr.size()) {
+    return compExOp.emitOpError("expexted at least one index for ")
+           << resultType;


You mean spv.CompositeExtract here?

Thanks, fixed.

antiagainst · 2019-07-11T18:08:37Z

lib/SPIRV/SPIRVOps.cpp

+  }
+
+  std::pair<Type, StringRef> resultPair;
+  switch (compositeType.getKind()) {


This should be simplified after letting CompositeType to include VectorType.

antiagainst · 2019-07-11T18:36:41Z

lib/SPIRV/SPIRVTypes.cpp

+    return cast<StructType>().getMemberType(index);
+  case spirv::TypeKind::Array:
+    return cast<ArrayType>().getElementType();
+  default:


Missing VectorType

antiagainst · 2019-07-11T18:36:58Z

lib/SPIRV/SPIRVTypes.cpp

+  case spirv::TypeKind::Array:
+    return cast<ArrayType>().getElementType();
+  default:
+    assert(0 && "invalid composite type");


Please use llvm_unreachable here.

Thanks, fixed.

antiagainst · 2019-07-11T18:37:09Z

lib/SPIRV/SPIRVTypes.cpp

+    return cast<StructType>().getNumMembers();
+  case spirv::TypeKind::Array:
+    return cast<ArrayType>().getElementCount();
+  default:


Missing VectorType

Thanks, updated.

antiagainst · 2019-07-11T18:37:18Z

lib/SPIRV/SPIRVTypes.cpp

+  case spirv::TypeKind::Array:
+    return cast<ArrayType>().getElementCount();
+  default:
+    assert(0 && "invalid composite type");


Also please use llvm_unreachable here

Thanks, fixed.

antiagainst · 2019-07-11T18:37:39Z

test/SPIRV/ops.mlir

@@ -496,3 +632,5 @@ func @cannot_be_generic_storage_class(%arg0: f32) -> () {
  %0 = spv.Variable : !spv.ptr<f32, Generic>
  return
 }
+


Redundant empty lines :)

Thanks, fixed.

denis0x0D · 2019-07-11T22:48:11Z

@antiagainst thanks for the review! I've updated the patch, can you please take a look again :) Thanks!

antiagainst

Awesome, thanks!

River707 · 2019-07-11T23:06:01Z

include/mlir/SPIRV/SPIRVTypes.h

+// StructType.
+class CompositeType : public Type {
+public:
+  using ImplType = DefaultTypeStorage;


You don't need to specify this, ImplType already defaults to DefaultTypeStorage.

@River707 Oh, my fault, thanks! Trying to get more familiar with MLIR.

CompositeExtractOp allows to extract a part of a composite object.

denis0x0D · 2019-07-11T23:17:47Z

@antiagainst @River707 thanks for review! Updated regarding to the latest comment.

antiagainst · 2019-07-12T16:02:31Z

This is now landed as b31675b. Thanks a lot for your contribution, @denis0x0D!

denis0x0D · 2019-07-12T17:16:06Z

@antiagainst thanks a lot! It would be nice, if you have some other tasks, not assigned to someone, which I can help with! Thanks.

antiagainst · 2019-07-12T17:19:30Z

@denis0x0D, that's awesome! We certainly have lots to do and I really appreciate your help here! :) Let me create some other issues and assign to you. :)

denis0x0D · 2019-07-12T17:23:18Z

@antiagainst thanks a lot! BTW, I will be in travel in [15, 21) of July, so, if it possible, some issue which I can start from 21-th of July.

antiagainst · 2019-07-13T13:01:16Z

@denis0x0D, sure! Thanks for letting me know! I wonder whether you can help to add spv.AccessChain too. Given that you've done spv.CompositeExtract, it should be quite similar. I've just landed 9a8202e, so you can use it to inject the basic definition into SPIRVOps.td with ./define_inst.sh OpAccessChain and update according to the spec. But certainly no pressure! Just let me know. Thanks again! :)

denis0x0D · 2019-07-13T14:14:19Z

@antiagainst thanks a lot for your time! It would be nice to implement OpAccessChain op, if it can wait until the next week, I'll take it wih a pleasure.
I see that helpful script gen_spirv_dialect.py, thanks!

antiagainst · 2019-07-15T12:50:00Z

No worries! Let's see whether we can get it done this week. If not, you are free to take it next week! Otherwise we can certainly use your help somewhere else. :)

denis0x0D · 2019-07-22T11:08:50Z

@antiagainst is it ok if I'll implement OpAccessChain? If noone works on it. Thanks.

antiagainst · 2019-07-22T13:00:49Z

@denis0x0D, yup, feel free to take it! Thanks a lot! :)

denis0x0D · 2019-07-22T18:51:46Z

@antiagainst thanks! Can you please answer some quick question about implementation, I want to make sure, that I understand it in right way.
In case of AccessChainOp it creates a pointer into composite type from pointer to composite type, the result pointer type must be provided by walking the Base's type hierarchy down to last provided index; the indexes are in SSA forms, so we can't walk down to last provided index during compile time, or I'm missing something. In parser we need to resolve the SSA values provided by Base (ssa-id) and get the type of result. to add it into list So, the ebnf form must look like this:

 op ::= ssa-id `=` `spv.AccessChain` ssa-use
           `[` ssa-use (`,` ssa-use)* `]`
           `:` pointer-type `,` pointer-type

for example

%result_ptr = spv.AccessChain %composite_ptr[%index0] : !spv.ptr<!spv.struct<f32, spv.array<4xf32>>, Function>, !spv.ptr<!spv.array<4xf32>, Function>

The first pointer-type is a type of composite object, the second one is a result type, in this case we can easily resolve the base type and result type.
But I might miss something, please correct me if I'm wrong.

antiagainst · 2019-07-22T20:08:37Z

@denis0x0D:

so we can't walk down to last provided index during compile time, or I'm missing something.

We can get the accessed component's type statically; it's just that we are not guaranteed to be in bounds dynamically. An vector/array/runtime-array type contains elements of the same type, so we will just get its element type. For structure type which contains heterogeneous elements, the spec requires the index to be from an OpConstant so we can statically deduce what type the accessed component is of.

For the trailing types in the custom assembly form, I think only output the composite's type should suffice?

denis0x0D · 2019-07-23T12:15:13Z

@antiagainst oh, I see, we can get an Operation associated with SSA Value (getDefiningOp) and thereofore all attributes (actual value of ConstantOp) to deduce the type extracted from the Composite object, sorry for the stupid question.
Thanks.

googlebot added the cla: yes label Jul 9, 2019

joker-eph requested a review from antiagainst July 9, 2019 15:35

joker-eph assigned antiagainst Jul 9, 2019

antiagainst suggested changes Jul 9, 2019

View reviewed changes

jpienaar added the ready to pull label Jul 9, 2019

antiagainst added the kokoro:run label Jul 9, 2019

kokoro-team removed the kokoro:run label Jul 9, 2019

denis0x0D force-pushed the sandbox/composite_extract branch from c5a12c4 to 5511a89 Compare July 11, 2019 14:19

antiagainst suggested changes Jul 11, 2019

View reviewed changes

denis0x0D force-pushed the sandbox/composite_extract branch from 5511a89 to dee9692 Compare July 11, 2019 22:42

antiagainst approved these changes Jul 11, 2019

View reviewed changes

antiagainst added the kokoro:run label Jul 11, 2019

kokoro-team removed the kokoro:run label Jul 11, 2019

River707 reviewed Jul 11, 2019

View reviewed changes

[spirv] Add CompositeExtractOp operation.

8ce9295

CompositeExtractOp allows to extract a part of a composite object.

denis0x0D force-pushed the sandbox/composite_extract branch from dee9692 to 8ce9295 Compare July 11, 2019 23:12

antiagainst added the kokoro:run label Jul 11, 2019

kokoro-team removed the kokoro:run label Jul 11, 2019

jpienaar closed this in b31675b Jul 12, 2019

antiagainst mentioned this pull request Jul 12, 2019

Add spv.CompositeExtract #42

Closed

bondhugula mentioned this pull request Oct 11, 2019

IR printing (-print-ir-after-all) crash #182

Closed

	/// This is a common base class between Vector, UnrankedTensor, RankedTensor,
	/// and MemRef types because they share behavior and semantics around shape,
	/// rank, and fixed element type. Any type with these semantics should inherit
	/// from ShapedType.
	class ShapedType : public Type {
	public:
	using ImplType = detail::ShapedTypeStorage;
	using Type::Type;

	/// Return the element type.
	Type getElementType() const;

	/// If an element type is an integer or a float, return its width. Otherwise,
	/// abort.
	unsigned getElementTypeBitWidth() const;

	/// If this is a ranked type, return the number of elements. Otherwise, abort.
	int64_t getNumElements() const;

	/// If this is a ranked type, return the rank. Otherwise, abort.
	int64_t getRank() const;

	/// Whether or not this is a ranked type. Memrefs, vectors and ranked tensors
	/// have a rank, while unranked tensors do not.
	bool hasRank() const;

	/// If this is a ranked type, return the shape. Otherwise, abort.
	ArrayRef<int64_t> getShape() const;

	/// If this is unranked type or any dimension has unknown size (<0), it
	/// doesn't have static shape. If all dimensions have known size (>= 0), it
	/// has static shape.
	bool hasStaticShape() const;

	/// If this is a ranked type, return the number of dimensions with dynamic
	/// size. Otherwise, abort.
	int64_t getNumDynamicDims() const;

	/// If this is ranked type, return the size of the specified dimension.
	/// Otherwise, abort.
	int64_t getDimSize(int64_t i) const;

	/// Get the total amount of bits occupied by a value of this type. This does
	/// not take into account any memory layout or widening constraints, e.g. a
	/// vector<3xi57> is reported to occupy 3x57=171 bit, even though in practice
	/// it will likely be stored as in a 4xi64 vector register. Fail an assertion
	/// if the size cannot be computed statically, i.e. if the type has a dynamic
	/// shape or if its elemental type does not have a known bit width.
	int64_t getSizeInBits() const;

	/// Methods for support type inquiry through isa, cast, and dyn_cast.
	static bool classof(Type type) {
	return type.getKind() == StandardTypes::Vector \|\|
	type.getKind() == StandardTypes::RankedTensor \|\|
	type.getKind() == StandardTypes::UnrankedTensor \|\|
	type.getKind() == StandardTypes::MemRef;
	}

	/// Whether the given dimension size indicates a dynamic dimension.
	static constexpr bool isDynamic(int64_t dSize) { return dSize < 0; }
	};

	/// Vector types represent multi-dimensional SIMD vectors, and have a fixed
	/// known constant shape with one or more dimension.
	class VectorType
	: public Type::TypeBase<VectorType, ShapedType, detail::VectorTypeStorage> {
	public:
	using Base::Base;

	/// Get or create a new VectorType of the provided shape and element type.
	/// Assumes the arguments define a well-formed VectorType.
	static VectorType get(ArrayRef<int64_t> shape, Type elementType);

	/// Get or create a new VectorType of the provided shape and element type
	/// declared at the given, potentially unknown, location. If the VectorType
	/// defined by the arguments would be ill-formed, emit errors and return
	/// nullptr-wrapping type.
	static VectorType getChecked(ArrayRef<int64_t> shape, Type elementType,
	Location location);

	/// Verify the construction of a vector type.
	static LogicalResult
	verifyConstructionInvariants(llvm::Optional<Location> loc,
	MLIRContext *context, ArrayRef<int64_t> shape,
	Type elementType);

	/// Returns true of the given type can be used as an element of a vector type.
	/// In particular, vectors can consist of integer or float primitives.
	static bool isValidElementType(Type t) { return t.isIntOrFloat(); }

	ArrayRef<int64_t> getShape() const;

	/// Methods for support type inquiry through isa, cast, and dyn_cast.
	static bool kindof(unsigned kind) { return kind == StandardTypes::Vector; }
	};

[spirv] Add CompositeExtractOp operation. #44

[spirv] Add CompositeExtractOp operation. #44

Conversation

denis0x0D commented Jul 9, 2019

antiagainst left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

denis0x0D commented Jul 9, 2019

denis0x0D commented Jul 11, 2019

antiagainst left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

denis0x0D commented Jul 11, 2019

antiagainst left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

denis0x0D commented Jul 11, 2019

antiagainst commented Jul 12, 2019

denis0x0D commented Jul 12, 2019

antiagainst commented Jul 12, 2019

denis0x0D commented Jul 12, 2019

antiagainst commented Jul 13, 2019

denis0x0D commented Jul 13, 2019

antiagainst commented Jul 15, 2019

denis0x0D commented Jul 22, 2019

antiagainst commented Jul 22, 2019

denis0x0D commented Jul 22, 2019

antiagainst commented Jul 22, 2019 • edited Loading

denis0x0D commented Jul 23, 2019

antiagainst commented Jul 22, 2019 •

edited

Loading