Histogram skeleton. #3502

prak-nv · 2021-11-17T20:41:33Z

Signed-off-by: Piotr Rak [email protected]

Description

Bug fix (non-breaking change which fixes an issue)
New feature (non-breaking change which adds functionality)
Breaking change (fix or feature that would cause existing functionality to not work as expected)
Refactoring (Redesign of existing code that doesn't affect functionality)
Other (e.g. Documentation, Tests, Configuration)

What happened in this PR

Additional information

Affected modules and functionalities:

Key points relevant for the review:

Checklist

Tests

Documentation

DALI team only

Requirements

Implements new requirements
Affects existing requirements
N/A

REQ IDs: N/A

JIRA TASK: N/A

mzient · 2022-01-12T12:51:19Z

dali/operators/generic/reduce/histogram.h

+  int dim = ndims - hist_dim;
+
+  // Starting from inner dimension, look if we should reduce this axis
+  // If we can do so until we can collapse next dimention.
+  auto raxis = reduction_axes.rbegin();
+
+  for (; raxis != reduction_axes.rend(); ++raxis) {
+    // TODO: Handle multidimentional histograms correctly
+    if (dim != *raxis) {
+      break;
+    }
+    --dim;
+  }
+
+  // If there's no reduction axes left, we won't need transpose any axis.
+  if (raxis == reduction_axes.rend())
+    return true;
+
+  return false;


This seems a bit overcomplicated - isn't it equivalent to the following?

Suggested change

int dim = ndims - hist_dim;

// Starting from inner dimension, look if we should reduce this axis

// If we can do so until we can collapse next dimention.

auto raxis = reduction_axes.rbegin();

for (; raxis != reduction_axes.rend(); ++raxis) {

// TODO: Handle multidimentional histograms correctly

if (dim != *raxis) {

break;

}

--dim;

}

// If there's no reduction axes left, we won't need transpose any axis.

if (raxis == reduction_axes.rend())

return true;

return false;

if (reduction_axes.size() != ndims - hist_dims)

return false; // not all dimensions reduced

for (int i = 0; i < ndims - hist_dims; i++)

if (reduction_axes[i] != i)

return false;

}

return true

mzient · 2022-01-12T13:10:39Z

dali/operators/generic/reduce/histogram.h

+
+    SmallVector<int, 6> axes_order;
+    axes_order.reserve(ndims);
+    for (int axis : non_rediction_axes) {


Suggested change

for (int axis : non_rediction_axes) {

for (int axis : non_reduction_axes) {

mzient · 2022-01-12T13:13:12Z

dali/operators/generic/reduce/histogram.h

+    const int ndims = input_shapes.sample_dim();
+
+    auto shape_span
+    auto non_rediction_axes = GetNonReductionAxes(ndims);


Suggested change

auto non_rediction_axes = GetNonReductionAxes(ndims);

auto non_reduction_axes = GetNonReductionAxes(ndims);

However, how about using bit masks for reduced axes? This would greatly simplify the code. You'd create a mask once and then you'd just check if given axis is marked as reduced or not. We even have a bitmask class, so there's no need to manually shift/mask stuff.

mzient · 2022-01-12T13:17:09Z

dali/operators/generic/reduce/histogram.h

+  return false;
+}
+
+// Collapses all inner dimensions


Can't we also collapse all outer dimensions?
After rearranging the axes so that we have
non-reduced reduced [channel]
We can then collapse (or expand!) each of these groups, so that we have exactly one non-reduced dimension, one reduced dimension and one channel dimension.
If it happens, that one of these groups is empty, we can always insert a phony axis with extent 1.

mzient · 2022-01-24T13:44:43Z

dali/operators/generic/reduce/histogram.h

+                                int hist_dim = 1) {
+  int dim = ndims - hist_dim;
+
+  DALI_ENFORCE(dim >= 1);


I don't think simple queries like that should throw. Passing hist_dim < 1 constitutes a coding error. Since this function is internal, assert should be enough.

dali-automaton · 2022-01-27T16:14:54Z

CI MESSAGE: [3840090]: BUILD STARTED

mzient · 2022-02-07T16:38:55Z

include/dali/core/tensor_shape.h

+
+  TensorListShape<ret_ndim> result(nshapes, dyn_out_ndim);
+
+  if (out_ndim == 0) {


Suggested change

if (out_ndim == 0) {

if (dyn_out_ndim == 0) {

mzient · 2022-02-07T16:40:18Z

include/dali/core/tensor_shape.h

+
+  const int dyn_out_ndim = shape.size() - 1;
+
+  int nshapes = shape[0];


Suggested change

int nshapes = shape[0];

int outer_extent = shape[0];

or

Suggested change

int nshapes = shape[0];

int nsamples = shape[0];

mzient · 2022-02-08T14:17:49Z

dali/operators/generic/reduce/histogram.cc

+}
+
+void HistogramCPU::PrepareInputShapesForTranspose(const TensorListShape<> &input_shapes,
+                                                  const SmallVector<int, 6> &non_reduction_axes) {


I think it would be easier to work with a bit mask or a set.

mzient · 2022-03-15T14:12:18Z

dali/operators/generic/histogram/histogram.h

+  ~HistogramCPU() override = default;
+
+ private:
+  int VerifyRangeArguments(const workspace_t<CPUBackend> &ws, int num_samples);


Grammar Nazi: Verify -> Validate

mzient · 2022-03-15T14:31:15Z

dali/operators/generic/histogram/histogram.cc

+  auto lo_view = view<const float>(ranges_lo);
+  auto hi_view = view<const float>(ranges_hi);
+
+  int hist_dim = ranges_lo.num_samples() / num_samples;


Perhaps it would be better to enforce exact shape (scalar when there are is no channel dimension and [num_channels] otherwise).

mzient · 2022-03-15T14:34:01Z

dali/operators/generic/histogram/histogram.cc

+int HistogramCPU::VerifyNonUniformRangeArguments(const workspace_t<CPUBackend> &ws, int num_samples) {
+  assert(!uniform_);
+
+  DALI_ENFORCE(ws.NumInput() % 2 == 1, "Should have both ranges"); // FIXME message


Waaait... what?

Signed-off-by: Piotr Rak <[email protected]>

jantonguirao · 2022-04-07T10:18:25Z

dali/operators/generic/histogram/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.


Suggested change

# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.

# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.

To be precise:

Suggested change

# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.

# Copyright (c) 2019-2022, NVIDIA CORPORATION. All rights reserved.

or

Suggested change

# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.

# Copyright (c) 2019, 2022, NVIDIA CORPORATION. All rights reserved.

jantonguirao · 2022-04-07T10:18:47Z

dali/operators/generic/histogram/CMakeLists.txt

+# Get all the source files and dump test files
+collect_headers(DALI_INST_HDRS PARENT_SCOPE)
+collect_sources(DALI_OPERATOR_SRCS PARENT_SCOPE)
+collect_test_sources(DALI_OPERATOR_TEST_SRCS PARENT_SCOPE)


nitpick: missing empty line at the end

jantonguirao · 2022-04-07T10:19:01Z

dali/operators/generic/histogram/histogram.h

@@ -0,0 +1,102 @@
+// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.


Suggested change

// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

// Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

jantonguirao · 2022-04-07T10:20:07Z

dali/operators/generic/reduce/axes_helper.h

@@ -0,0 +1,60 @@
+// Copyright (c) 2020-2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.


Suggested change

// Copyright (c) 2020-2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

// Copyright (c) 2020-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

jantonguirao · 2022-04-07T10:22:23Z

dali/pipeline/operator/op_schema.h

@@ -993,7 +993,7 @@ inline T OpSchema::GetDefaultValueForArgument(const std::string &s) const {
 }

 #define DALI_SCHEMA_REG(OpName)      \
-  int DALI_OPERATOR_SCHEMA_REQUIRED_FOR_##OpName() {        \
+  int CONCAT_2(DALI_OPERATOR_SCHEMA_REQUIRED_FOR_, OpName)() {        \


Just a note. In general, I think it's best to keep unrelated changes separate (separate small PR)

jantonguirao · 2022-04-07T11:58:55Z

dali/operators/generic/histogram/histogram.cc

+template <>
+struct CVMatType<uint8_t> {
+  static int get(int nchannel) noexcept {
+    return CV_MAKETYPE(CV_8U, nchannel);
+  }
+};


The struct seems unnecessary. How about:

template <typename Ty_> int CVMatType(int nchannel) { return CV_MAKETYPE(CV_8U, nchannel); }

jantonguirao · 2022-04-07T12:07:03Z

dali/operators/generic/histogram/histogram.cc

+  std::vector<Type *> tmp_pointers;
+  tmp_pointers.reserve(transposed_shapes.num_samples());
+
+  for (int i = 0; i < transposed_shapes.num_samples(); ++i) {
+    auto tmp = scratch.template AllocTensor<mm::memory_kind::host, Type>(transposed_shapes[i]);
+    tmp_pointers.push_back(tmp.data);
+  }
+
+  TensorListView<StorageCPU, Type> transpose_out_view(std::move(tmp_pointers),
+                                                      std::move(transposed_shapes));


Suggested change

std::vector<Type *> tmp_pointers;

tmp_pointers.reserve(transposed_shapes.num_samples());

for (int i = 0; i < transposed_shapes.num_samples(); ++i) {

auto tmp = scratch.template AllocTensor<mm::memory_kind::host, Type>(transposed_shapes[i]);

tmp_pointers.push_back(tmp.data);

}

TensorListView<StorageCPU, Type> transpose_out_view(std::move(tmp_pointers),

std::move(transposed_shapes));

auto transpose_out_view = scratch.template AllocTensorList<mm::memory_kind::host, Type>(std::move(transposed_shapes));

}

jantonguirao · 2022-04-07T12:07:50Z

dali/operators/generic/histogram/histogram.cc

+template <typename Type, typename ScratchAlloc, typename Coll>
+TensorListView<StorageCPU, const Type> transpose_view(
+    dali::ThreadPool &thread_pool, ScratchAlloc &scratch,
+    const TensorListView<StorageCPU, const Type> &in_view, const Coll &transpose_axes_order) {


Suggested change

template <typename Type, typename ScratchAlloc, typename Coll>

TensorListView<StorageCPU, const Type> transpose_view(

dali::ThreadPool &thread_pool, ScratchAlloc &scratch,

const TensorListView<StorageCPU, const Type> &in_view, const Coll &transpose_axes_order) {

template <typename Type>

TensorListView<StorageCPU, const Type> transpose_view(

dali::ThreadPool &thread_pool, Scratchpad &scratch,

const TensorListView<StorageCPU, const Type> &in_view, span<const int> transpose_axes_order) {

Scratchpad is an interface. Also, I think we could use span for the axes

jantonguirao · 2022-04-07T12:10:27Z

dali/operators/generic/histogram/histogram.cc

+  for (int i = 0; i < transpose_out_view.num_samples(); ++i) {
+    thread_pool.AddWork([&, i](int thread_id) {
+      auto perm = make_span(transpose_axes_order);
+      kernels::Transpose(transpose_out_view[i], in_view[i], perm);


maybe kernels::TransposeGrouped as it can automatically simplify the shapes when applicable?

jantonguirao · 2022-04-07T12:12:29Z

dali/operators/generic/histogram/histogram.cc

+    });
+  }
+  thread_pool.RunAll(true);
+  return reinterpret<const Type>(transpose_out_view, transpose_out_view.shape);


Suggested change

return reinterpret<const Type>(transpose_out_view, transpose_out_view.shape);

return transpose_out_view;

would do, I think

Yeah, the conversion to const view is implicit. Reinterpret is a heavy hammer - like with a cast, it will hide any possible errors until run-time.

mzient · 2022-04-07T12:26:55Z

dali/operators/generic/histogram/histogram.cc

+using namespace dali;
+using namespace dali::hist_detail;
+
+#define id_(x) x


That's quite unnecessary.

mzient · 2022-04-07T12:47:54Z

dali/operators/generic/histogram/histogram.cc

+    auto range_view = view<const float>(dim_ranges);
+    for (int i = 0; i < range_view[sample].num_elements(); ++i) {
+      ranges.push_back(range_view.tensor_data(sample)[i]);


I'd recommend hoisting the sample access to the outer loop.
Also, num_elements() is not trivial and the compiler might fail to identify it as a loop invariant.

Suggested change

auto range_view = view<const float>(dim_ranges);

for (int i = 0; i < range_view[sample].num_elements(); ++i) {

ranges.push_back(range_view.tensor_data(sample)[i]);

auto range_view = view<const float>(dim_ranges)[sample];

for (int i = 0, n = range_view.num_elements(); i < n; ++i) {

ranges.push_back(range_view.data[i]);

mzient · 2022-04-07T12:55:24Z

dali/operators/generic/histogram/histogram.cc

+template <typename Ty_>
+struct CVMatType {
+  static int get(int) {
+    DALI_ENFORCE(false, "Unreachable - invalid type");
+  }
+};


How about getting rid of the specializations and going with:

Suggested change

template <typename Ty_>

struct CVMatType {

static int get(int) {

DALI_ENFORCE(false, "Unreachable - invalid type");

}

};

template <typename ChannelType>

struct CVMatType {

static int get(int nchannels) {

return CV_MAKETYPE(cv::DataDepth<ChannelType>>::type, nchannels);

}

};

?

Also, the trailing underscore in template arguments is not a coding style we use.

jantonguirao · 2022-04-07T12:16:37Z

dali/operators/generic/histogram/histogram.cc

+    if (is_identity_) {
+      auto out_view_id = view<Type>(output);
+      run_identity<Type>(thread_pool, in_view, out_view_id);
+       return;


indentation is slightly off

jantonguirao · 2022-04-07T12:20:56Z

dali/operators/generic/histogram/histogram.cc

+        std::vector<cv::Mat> images = {
+          cv::Mat(1, in_sizes.data(), in_type, splited_in_views[i].data)};
+
+        cv::InputArray input_mat(images);
+


I don't think you need an cv::InputArray. You can pass cv::Mat to cv::calcHist

jantonguirao · 2022-04-07T12:22:08Z

dali/operators/generic/histogram/histogram.cc

+          TensorView<StorageCPU, float> hist_view(hist_data, splited_out_views[i].shape);
+          kernels::copy(splited_out_views[i], hist_view);


Indentation is off in those two lines

jantonguirao · 2022-04-07T12:23:22Z

dali/operators/generic/histogram/histogram.cc

+  ret.resize(num_samples, hist_dim_);
+
+  for (int i = 0; i < num_samples; ++i) {
+    TensorShape<> bin_shape{make_span(batch_bins_[i].data(), hist_dim_)};


Suggested change

TensorShape<> bin_shape{make_span(batch_bins_[i].data(), hist_dim_)};

TensorShape<> bin_shape{make_span(batch_bins_[i])};

jantonguirao · 2022-04-07T12:28:26Z

dali/operators/generic/histogram/histogram.cc

+  split_mapping_ = std::move(split_mapping);
+  splited_input_shapes_ = std::move(splited_input_shapes);
+  splited_output_shapes_ = std::move(splited_output_shapes);


Why not operating directly on those? Avoiding unnecessary allocations

jantonguirao · 2022-04-07T12:50:53Z

dali/operators/generic/histogram/histogram.cc

+    .AddParent("HistogramBase");
+
+DALI_SCHEMA(UniformHistogramOpName)
+    .DocStr(R"code(Calculates 1D or ND histogram of the input tensor with uniform histogram bin ranges.


Suggested change

.DocStr(R"code(Calculates 1D or ND histogram of the input tensor with uniform histogram bin ranges.

.DocStr(R"code(Calculates 1D or ND histogram of with uniform histogram bin ranges.

jantonguirao · 2022-04-07T12:56:07Z

dali/operators/generic/histogram/histogram.cc

+Calculates histogram of of uniform bin ranges, second input tensor specifies lower bound of range of values and third argument specfies
+upper range of values in each histogram dimension.
+
+For example lower range (2nd tensor argument) ``[0]`` and upper range (3rd tensor argument) ``[255]`` and ``num_bins=[16]`` will calculate histogram
+with 16 bins of uniformly subdivided in range ``[0, 255]``


Suggested change

Calculates histogram of of uniform bin ranges, second input tensor specifies lower bound of range of values and third argument specfies

upper range of values in each histogram dimension.

For example lower range (2nd tensor argument) ``[0]`` and upper range (3rd tensor argument) ``[255]`` and ``num_bins=[16]`` will calculate histogram

with 16 bins of uniformly subdivided in range ``[0, 255]``

This operators calculates ``num_bins`` uniform ranges covering the range defined by the lower bound and upper bound defined by positional inputs.

For example, a lower range (2nd positional input) ``[0]`` and an upper range (3rd positional input) ``[255]``, together with a ``num_bins=16`` will calculate a histogram with 16 uniform bins in the range ``[0, 255]``.

jantonguirao · 2022-04-07T12:56:57Z

dali/operators/generic/histogram/histogram.cc

+The histogram of the input tensor when ``channel_axis`` or ``channel_axis_name`` is specified is calculated as multidimensional
+histogram ie. as if histogram would be calculated for each seperate channel of this axis.
+If channel axis is not specified 1D histogram is calculated.
+Current implentation supports up to 32 channels for histogram calculation.
+
+Histogram calculation supports specifing arbitrary axes of reduction.
+
+For example for tensor with layout "HWC" one could calculate different single and multidimentional histograms.


I posted some comments in the other occurrence of this text. I think those comments apply here as well

jantonguirao · 2022-04-07T12:58:52Z

dali/operators/generic/histogram/histogram.h

+  bool IsIdentityTransform() const {
+    return is_identity_;
+  }
+  bool IsSimpleReduction1() const;


where is this used?

jantonguirao · 2022-04-07T12:59:16Z

dali/operators/generic/histogram/histogram.h

+  std::vector<std::vector<float>> batch_ranges_;
+  std::vector<SmallVector<int, 3>> batch_bins_;
+  ArgValue<int, 1> param_num_bins_;
+  kernels::ScratchpadAllocator transpose_mem_;


Suggested change

kernels::ScratchpadAllocator transpose_mem_;

kernels::DynamicScratchpad transpose_mem_;

jantonguirao · 2022-04-07T13:03:10Z

dali/test/python/test_operator_histogram.py

+        for ret_sz, expected_sz in zip(out.shape(), sz.as_array()):
+            assert(ret_sz == tuple(expected_sz))
+
+def test_uniform_hist_args():


instead of running several tests in one function, I'd suggest to create independent functions for each test. This way when a testcase fails, we can see exactly which one.

mzient · 2022-04-11T12:18:46Z

dali/operators/generic/histogram/histogram.cc

+  }
+
+  split_mapping_ = std::move(split_mapping);
+  splited_input_shapes_ = std::move(splited_input_shapes);


"Split" is an irregular verb. split/split/split.

Suggested change

splited_input_shapes_ = std::move(splited_input_shapes);

split_input_shapes_ = std::move(split_input_shapes);

prak-nv force-pushed the histogram_cpu branch 2 times, most recently from 29a20c2 to c3ccc6c Compare January 12, 2022 10:42

mzient reviewed Jan 12, 2022

View reviewed changes

prak-nv force-pushed the histogram_cpu branch from c3ccc6c to efcc9e3 Compare January 19, 2022 20:02

mzient reviewed Jan 24, 2022

View reviewed changes

prak-nv force-pushed the histogram_cpu branch from efcc9e3 to f7d86d1 Compare January 27, 2022 10:28

NVIDIA deleted a comment from dali-automaton Jan 27, 2022

prak-nv force-pushed the histogram_cpu branch 2 times, most recently from a399a60 to d9c477f Compare February 1, 2022 12:07

mzient reviewed Feb 7, 2022

View reviewed changes

mzient reviewed Feb 8, 2022

View reviewed changes

prak-nv force-pushed the histogram_cpu branch 9 times, most recently from 8ca05b9 to d221251 Compare February 17, 2022 21:26

prak-nv force-pushed the histogram_cpu branch 2 times, most recently from 2ee5046 to 606fafb Compare March 8, 2022 15:25

mzient reviewed Mar 15, 2022

View reviewed changes

JanuszL mentioned this pull request Mar 30, 2022

DALI 2022 roadmap #3774

Closed

[WIP] Histogram CPU

2e2fe4d

Signed-off-by: Piotr Rak <[email protected]>

prak-nv force-pushed the histogram_cpu branch from 606fafb to 2e2fe4d Compare April 7, 2022 00:01

jantonguirao assigned jantonguirao and mzient Apr 7, 2022

jantonguirao reviewed Apr 7, 2022

View reviewed changes

mzient reviewed Apr 7, 2022

View reviewed changes

jantonguirao reviewed Apr 7, 2022

View reviewed changes

mzient reviewed Apr 11, 2022

View reviewed changes

mzient removed their assignment Nov 10, 2022

JanuszL mentioned this pull request Jan 9, 2023

[QUESTION] Image histogram example #4549

Open

jantonguirao removed their assignment Jan 10, 2023

	for (int axis : non_rediction_axes) {
	for (int axis : non_reduction_axes) {

	auto non_rediction_axes = GetNonReductionAxes(ndims);
	auto non_reduction_axes = GetNonReductionAxes(ndims);


		TensorListShape<ret_ndim> result(nshapes, dyn_out_ndim);

		if (out_ndim == 0) {


		const int dyn_out_ndim = shape.size() - 1;

		int nshapes = shape[0];

		@@ -0,0 +1,18 @@
		# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.

	# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
	# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.

	# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
	# Copyright (c) 2019-2022, NVIDIA CORPORATION. All rights reserved.

	# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
	# Copyright (c) 2019, 2022, NVIDIA CORPORATION. All rights reserved.

		@@ -0,0 +1,102 @@
		// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

	// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
	// Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

		@@ -0,0 +1,60 @@
		// Copyright (c) 2020-2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

	// Copyright (c) 2020-2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
	// Copyright (c) 2020-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

	return reinterpret<const Type>(transpose_out_view, transpose_out_view.shape);
	return transpose_out_view;

		TensorView<StorageCPU, float> hist_view(hist_data, splited_out_views[i].shape);
		kernels::copy(splited_out_views[i], hist_view);

	TensorShape<> bin_shape{make_span(batch_bins_[i].data(), hist_dim_)};
	TensorShape<> bin_shape{make_span(batch_bins_[i])};

	.DocStr(R"code(Calculates 1D or ND histogram of the input tensor with uniform histogram bin ranges.
	.DocStr(R"code(Calculates 1D or ND histogram of with uniform histogram bin ranges.

	kernels::ScratchpadAllocator transpose_mem_;
	kernels::DynamicScratchpad transpose_mem_;

	splited_input_shapes_ = std::move(splited_input_shapes);
	split_input_shapes_ = std::move(split_input_shapes);

Histogram skeleton. #3502

Are you sure you want to change the base?

Histogram skeleton. #3502

Conversation

prak-nv commented Nov 17, 2021 • edited Loading

Description

What happened in this PR

Additional information

Checklist

Tests

Documentation

DALI team only

Requirements

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

dali-automaton commented Jan 27, 2022

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

mzient Mar 15, 2022 • edited Loading

Choose a reason for hiding this comment

mzient Mar 15, 2022 • edited Loading

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

mzient Apr 7, 2022 • edited Loading

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

prak-nv commented Nov 17, 2021 •

edited

Loading

mzient Mar 15, 2022 •

edited

Loading

mzient Mar 15, 2022 •

edited

Loading

mzient Apr 7, 2022 •

edited

Loading