Histogram skeleton. by prak-nv · Pull Request #3502 · NVIDIA/DALI

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

+  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

+
+    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

+    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

+  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

+                                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

+
+  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

+
+  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

+}
+
+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

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


Grammar Nazi: Verify -> Validate

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

+  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

+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

@@ -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

+# 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

@@ -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

@@ -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


 #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

+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

+  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

+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

+  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

+    });
+  }
+  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

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


That's quite unnecessary.

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

+    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

+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

+    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

+        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

+          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

+  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

+  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

+    .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

+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

+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

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


where is this used?

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

+  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

+        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

+  }
+
+  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

JanuszL added the Left_for_the_reference label Oct 31, 2025

	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);

Conversation

prak-nv commented Nov 17, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Description

What happened in this PR

Additional information

Checklist

Tests

Documentation

DALI team only

Requirements

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!

dali-automaton commented Jan 27, 2022

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!

mzient Mar 15, 2022 • 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!

mzient Mar 15, 2022 • 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!

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!

mzient Apr 7, 2022 • 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!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

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