mirror of
https://github.com/Z3Prover/z3
synced 2026-02-20 07:24:40 +00:00
add interpretations when there are ranges
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner
parent
65f38eac16
commit
2e4402c8f3
8 changed files with 427 additions and 158 deletions
|
|
@ -233,14 +233,25 @@ bool finite_set_decl_plugin::is_value(app * e) const {
|
|||
continue;
|
||||
}
|
||||
|
||||
bool is_setop =
|
||||
is_app_of(a, m_family_id, OP_FINITE_SET_UNION)
|
||||
|| is_app_of(a, m_family_id, OP_FINITE_SET_INTERSECT)
|
||||
|| is_app_of(a, m_family_id, OP_FINITE_SET_DIFFERENCE);
|
||||
// Check if it's a union
|
||||
if (is_app_of(a, m_family_id, OP_FINITE_SET_UNION)) {
|
||||
if (is_setop) {
|
||||
// Add arguments to todo list
|
||||
for (auto arg : *a)
|
||||
todo.push_back(arg);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (is_app_of(a, m_family_id, OP_FINITE_SET_RANGE)) {
|
||||
for (auto arg : *a)
|
||||
if (!m_manager->is_value(arg))
|
||||
return false;
|
||||
continue;
|
||||
}
|
||||
|
||||
// can add also ranges where lo and hi are values.
|
||||
|
||||
// If it's none of the above, it's not a value
|
||||
|
|
@ -271,3 +282,10 @@ bool finite_set_decl_plugin::are_distinct(app* e1, app* e2) const {
|
|||
// that the other doesn't contain. Such as (union (singleton a) (singleton b)) and (singleton c) where c is different from a, b.
|
||||
return false;
|
||||
}
|
||||
|
||||
func_decl *finite_set_util::mk_range_decl() {
|
||||
arith_util a(m_manager);
|
||||
sort *i = a.mk_int();
|
||||
sort *domain[2] = {i, i};
|
||||
return m_manager.mk_func_decl(m_fid, OP_FINITE_SET_RANGE, 0, nullptr, 2, domain, nullptr);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -195,6 +195,8 @@ public:
|
|||
return m_manager.mk_app(m_fid, OP_FINITE_SET_FILTER, arr, set);
|
||||
}
|
||||
|
||||
func_decl *mk_range_decl();
|
||||
|
||||
app * mk_range(expr* low, expr* high) {
|
||||
return m_manager.mk_app(m_fid, OP_FINITE_SET_RANGE, low, high);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ Revision History:
|
|||
--*/
|
||||
|
||||
#include "ast/ast.h"
|
||||
#include "ast/ast_pp.h"
|
||||
#include "ast/finite_set_decl_plugin.h"
|
||||
#include "ast/arith_decl_plugin.h"
|
||||
#include "ast/array_decl_plugin.h"
|
||||
|
|
@ -38,8 +39,8 @@ void finite_set_axioms::in_empty_axiom(expr *x) {
|
|||
expr_ref empty_set(u.mk_empty(elem_sort), m);
|
||||
expr_ref x_in_empty(u.mk_in(x, empty_set), m);
|
||||
|
||||
theory_axiom ax(m, "in-empty");
|
||||
ax.clause.push_back(m.mk_not(x_in_empty));
|
||||
theory_axiom* ax = alloc(theory_axiom, m, "in-empty");
|
||||
ax->clause.push_back(m.mk_not(x_in_empty));
|
||||
m_add_clause(ax);
|
||||
}
|
||||
|
||||
|
|
@ -50,27 +51,28 @@ void finite_set_axioms::in_union_axiom(expr *x, expr *a) {
|
|||
if (!u.is_union(a, b, c))
|
||||
return;
|
||||
|
||||
theory_axiom ax(m, "in-union");
|
||||
|
||||
expr_ref x_in_a(u.mk_in(x, a), m);
|
||||
expr_ref x_in_b(u.mk_in(x, b), m);
|
||||
expr_ref x_in_c(u.mk_in(x, c), m);
|
||||
|
||||
// (x in a) => (x in b) or (x in c)
|
||||
ax.clause.push_back(m.mk_not(x_in_a));
|
||||
ax.clause.push_back(x_in_b);
|
||||
ax.clause.push_back(x_in_c);
|
||||
m_add_clause(ax);
|
||||
theory_axiom *ax1 = alloc(theory_axiom, m, "in-union");
|
||||
ax1->clause.push_back(m.mk_not(x_in_a));
|
||||
ax1->clause.push_back(x_in_b);
|
||||
ax1->clause.push_back(x_in_c);
|
||||
m_add_clause(ax1);
|
||||
|
||||
// (x in b) => (x in a)
|
||||
theory_axiom ax2(m, "in-union");
|
||||
ax2.clause.push_back(m.mk_not(x_in_b));
|
||||
ax2.clause.push_back(x_in_a);
|
||||
theory_axiom* ax2 = alloc(theory_axiom, m, "in-union");
|
||||
ax2->clause.push_back(m.mk_not(x_in_b));
|
||||
ax2->clause.push_back(x_in_a);
|
||||
m_add_clause(ax2);
|
||||
|
||||
// (x in c) => (x in a)
|
||||
theory_axiom ax3(m, "in-union");
|
||||
ax3.clause.push_back(m.mk_not(x_in_c));
|
||||
ax3.clause.push_back(x_in_a);
|
||||
theory_axiom* ax3 = alloc(theory_axiom, m, "in-union");
|
||||
ax3->clause.push_back(m.mk_not(x_in_c));
|
||||
ax3->clause.push_back(x_in_a);
|
||||
m_add_clause(ax3);
|
||||
}
|
||||
|
||||
|
|
@ -86,22 +88,22 @@ void finite_set_axioms::in_intersect_axiom(expr *x, expr *a) {
|
|||
expr_ref x_in_c(u.mk_in(x, c), m);
|
||||
|
||||
// (x in a) => (x in b)
|
||||
theory_axiom ax1(m, "in-intersect");
|
||||
ax1.clause.push_back(m.mk_not(x_in_a));
|
||||
ax1.clause.push_back(x_in_b);
|
||||
theory_axiom* ax1 = alloc(theory_axiom, m, "in-intersect");
|
||||
ax1->clause.push_back(m.mk_not(x_in_a));
|
||||
ax1->clause.push_back(x_in_b);
|
||||
m_add_clause(ax1);
|
||||
|
||||
// (x in a) => (x in c)
|
||||
theory_axiom ax2(m, "in-intersect");
|
||||
ax2.clause.push_back(m.mk_not(x_in_a));
|
||||
ax2.clause.push_back(x_in_c);
|
||||
theory_axiom* ax2 = alloc(theory_axiom, m, "in-intersect");
|
||||
ax2->clause.push_back(m.mk_not(x_in_a));
|
||||
ax2->clause.push_back(x_in_c);
|
||||
m_add_clause(ax2);
|
||||
|
||||
// (x in b) and (x in c) => (x in a)
|
||||
theory_axiom ax3(m, "in-intersect");
|
||||
ax3.clause.push_back(m.mk_not(x_in_b));
|
||||
ax3.clause.push_back(m.mk_not(x_in_c));
|
||||
ax3.clause.push_back(x_in_a);
|
||||
theory_axiom* ax3 = alloc(theory_axiom, m, "in-intersect");
|
||||
ax3->clause.push_back(m.mk_not(x_in_b));
|
||||
ax3->clause.push_back(m.mk_not(x_in_c));
|
||||
ax3->clause.push_back(x_in_a);
|
||||
m_add_clause(ax3);
|
||||
}
|
||||
|
||||
|
|
@ -117,22 +119,22 @@ void finite_set_axioms::in_difference_axiom(expr *x, expr *a) {
|
|||
expr_ref x_in_c(u.mk_in(x, c), m);
|
||||
|
||||
// (x in a) => (x in b)
|
||||
theory_axiom ax1(m, "in-difference");
|
||||
ax1.clause.push_back(m.mk_not(x_in_a));
|
||||
ax1.clause.push_back(x_in_b);
|
||||
theory_axiom* ax1 = alloc(theory_axiom, m, "in-difference");
|
||||
ax1->clause.push_back(m.mk_not(x_in_a));
|
||||
ax1->clause.push_back(x_in_b);
|
||||
m_add_clause(ax1);
|
||||
|
||||
// (x in a) => not (x in c)
|
||||
theory_axiom ax2(m, "in-difference");
|
||||
ax2.clause.push_back(m.mk_not(x_in_a));
|
||||
ax2.clause.push_back(m.mk_not(x_in_c));
|
||||
theory_axiom* ax2 = alloc(theory_axiom, m, "in-difference");
|
||||
ax2->clause.push_back(m.mk_not(x_in_a));
|
||||
ax2->clause.push_back(m.mk_not(x_in_c));
|
||||
m_add_clause(ax2);
|
||||
|
||||
// (x in b) and not (x in c) => (x in a)
|
||||
theory_axiom ax3(m, "in-difference");
|
||||
ax3.clause.push_back(m.mk_not(x_in_b));
|
||||
ax3.clause.push_back(x_in_c);
|
||||
ax3.clause.push_back(x_in_a);
|
||||
theory_axiom* ax3 = alloc(theory_axiom, m, "in-difference");
|
||||
ax3->clause.push_back(m.mk_not(x_in_b));
|
||||
ax3->clause.push_back(x_in_c);
|
||||
ax3->clause.push_back(x_in_a);
|
||||
m_add_clause(ax3);
|
||||
}
|
||||
|
||||
|
|
@ -145,11 +147,11 @@ void finite_set_axioms::in_singleton_axiom(expr *x, expr *a) {
|
|||
|
||||
expr_ref x_in_a(u.mk_in(x, a), m);
|
||||
|
||||
theory_axiom ax(m, "in-singleton");
|
||||
theory_axiom* ax = alloc(theory_axiom, m, "in-singleton");
|
||||
if (x == b) {
|
||||
// If x and b are syntactically identical, then (x in a) is always true
|
||||
|
||||
ax.clause.push_back(x_in_a);
|
||||
ax->clause.push_back(x_in_a);
|
||||
m_add_clause(ax);
|
||||
return;
|
||||
}
|
||||
|
|
@ -157,17 +159,42 @@ void finite_set_axioms::in_singleton_axiom(expr *x, expr *a) {
|
|||
expr_ref x_eq_b(m.mk_eq(x, b), m);
|
||||
|
||||
// (x in a) => (x == b)
|
||||
ax.clause.push_back(m.mk_not(x_in_a));
|
||||
ax.clause.push_back(x_eq_b);
|
||||
ax->clause.push_back(m.mk_not(x_in_a));
|
||||
ax->clause.push_back(x_eq_b);
|
||||
m_add_clause(ax);
|
||||
ax.clause.reset();
|
||||
ax = alloc(theory_axiom, m, "in-singleton");
|
||||
|
||||
// (x == b) => (x in a)
|
||||
ax.clause.push_back(m.mk_not(x_eq_b));
|
||||
ax.clause.push_back(x_in_a);
|
||||
ax->clause.push_back(m.mk_not(x_eq_b));
|
||||
ax->clause.push_back(x_in_a);
|
||||
m_add_clause(ax);
|
||||
}
|
||||
|
||||
void finite_set_axioms::in_singleton_axiom(expr* a) {
|
||||
expr *b = nullptr;
|
||||
if (!u.is_singleton(a, b))
|
||||
return;
|
||||
|
||||
arith_util arith(m);
|
||||
|
||||
expr_ref b_in_a(u.mk_in(b, a), m);
|
||||
|
||||
auto ax = alloc(theory_axiom, m, "in-singleton");
|
||||
ax->clause.push_back(b_in_a);
|
||||
m_add_clause(ax);
|
||||
|
||||
ax = alloc(theory_axiom, m, "in-singleton");
|
||||
expr_ref bm1_in_a(u.mk_in(arith.mk_add(b, arith.mk_int(-1)), a), m);
|
||||
ax->clause.push_back(m.mk_not(bm1_in_a));
|
||||
m_add_clause(ax);
|
||||
|
||||
ax = alloc(theory_axiom, m, "in-singleton");
|
||||
expr_ref bp1_in_a(u.mk_in(arith.mk_add(b, arith.mk_int(1)), a), m);
|
||||
ax->clause.push_back(m.mk_not(bp1_in_a));
|
||||
}
|
||||
|
||||
|
||||
|
||||
// a := set.range(lo, hi)
|
||||
// (x in a) <=> (lo <= x <= hi)
|
||||
void finite_set_axioms::in_range_axiom(expr *x, expr *a) {
|
||||
|
|
@ -177,29 +204,58 @@ void finite_set_axioms::in_range_axiom(expr *x, expr *a) {
|
|||
|
||||
arith_util arith(m);
|
||||
expr_ref x_in_a(u.mk_in(x, a), m);
|
||||
expr_ref lo_le_x(arith.mk_le(lo, x), m);
|
||||
expr_ref x_le_hi(arith.mk_le(x, hi), m);
|
||||
expr_ref lo_le_x(arith.mk_le(arith.mk_sub(lo, x), arith.mk_int(0)), m);
|
||||
expr_ref x_le_hi(arith.mk_le(arith.mk_sub(x, hi), arith.mk_int(0)), m);
|
||||
m_rewriter(lo_le_x);
|
||||
m_rewriter(x_le_hi);
|
||||
|
||||
// (x in a) => (lo <= x)
|
||||
theory_axiom ax1(m, "in-range");
|
||||
ax1.clause.push_back(m.mk_not(x_in_a));
|
||||
ax1.clause.push_back(lo_le_x);
|
||||
theory_axiom* ax1 = alloc(theory_axiom, m, "in-range");
|
||||
ax1->clause.push_back(m.mk_not(x_in_a));
|
||||
ax1->clause.push_back(lo_le_x);
|
||||
m_add_clause(ax1);
|
||||
|
||||
// (x in a) => (x <= hi)
|
||||
theory_axiom ax2(m, "in-range");
|
||||
ax2.clause.push_back(m.mk_not(x_in_a));
|
||||
ax2.clause.push_back(x_le_hi);
|
||||
theory_axiom* ax2 = alloc(theory_axiom, m, "in-range");
|
||||
ax2->clause.push_back(m.mk_not(x_in_a));
|
||||
ax2->clause.push_back(x_le_hi);
|
||||
m_add_clause(ax2);
|
||||
|
||||
// (lo <= x) and (x <= hi) => (x in a)
|
||||
theory_axiom ax3(m, "in-range");
|
||||
ax3.clause.push_back(m.mk_not(lo_le_x));
|
||||
ax3.clause.push_back(m.mk_not(x_le_hi));
|
||||
ax3.clause.push_back(x_in_a);
|
||||
theory_axiom* ax3 = alloc(theory_axiom, m, "in-range");
|
||||
ax3->clause.push_back(m.mk_not(lo_le_x));
|
||||
ax3->clause.push_back(m.mk_not(x_le_hi));
|
||||
ax3->clause.push_back(x_in_a);
|
||||
m_add_clause(ax3);
|
||||
}
|
||||
|
||||
// a := set.range(lo, hi)
|
||||
// (not (set.in (- lo 1) r))
|
||||
// (not (set.in (+ hi 1) r))
|
||||
// (set.in lo r)
|
||||
// (set.in hi r)
|
||||
void finite_set_axioms::in_range_axiom(expr* r) {
|
||||
expr *lo = nullptr, *hi = nullptr;
|
||||
if (!u.is_range(r, lo, hi))
|
||||
return;
|
||||
theory_axiom* ax = alloc(theory_axiom, m, "range-bounds");
|
||||
ax->clause.push_back(u.mk_in(lo, r));
|
||||
m_add_clause(ax);
|
||||
|
||||
ax = alloc(theory_axiom, m, "range-bounds");
|
||||
ax->clause.push_back(u.mk_in(hi, r));
|
||||
m_add_clause(ax);
|
||||
|
||||
arith_util a(m);
|
||||
ax = alloc(theory_axiom, m, "range-bounds");
|
||||
ax->clause.push_back(m.mk_not(u.mk_in(a.mk_add(hi, a.mk_int(1)), r)));
|
||||
m_add_clause(ax);
|
||||
|
||||
ax = alloc(theory_axiom, m, "range-bounds");
|
||||
ax->clause.push_back(m.mk_not(u.mk_in(a.mk_add(lo, a.mk_int(-1)), r)));
|
||||
m_add_clause(ax);
|
||||
}
|
||||
|
||||
// a := set.map(f, b)
|
||||
// (x in a) <=> set.map_inverse(f, x, b) in b
|
||||
void finite_set_axioms::in_map_axiom(expr *x, expr *a) {
|
||||
|
|
@ -228,9 +284,9 @@ void finite_set_axioms::in_map_image_axiom(expr *x, expr *a) {
|
|||
expr_ref fx_in_a(u.mk_in(fx, a), m);
|
||||
|
||||
// (x in b) => f(x) in a
|
||||
theory_axiom ax(m, "in-map-image");
|
||||
ax.clause.push_back(m.mk_not(x_in_b));
|
||||
ax.clause.push_back(fx_in_a);
|
||||
theory_axiom* ax = alloc(theory_axiom, m, "in-map-image");
|
||||
ax->clause.push_back(m.mk_not(x_in_b));
|
||||
ax->clause.push_back(fx_in_a);
|
||||
m_add_clause(ax);
|
||||
}
|
||||
|
||||
|
|
@ -249,22 +305,22 @@ void finite_set_axioms::in_filter_axiom(expr *x, expr *a) {
|
|||
expr_ref px(autil.mk_select(p, x), m);
|
||||
|
||||
// (x in a) => (x in b)
|
||||
theory_axiom ax1(m, "in-filter");
|
||||
ax1.clause.push_back(m.mk_not(x_in_a));
|
||||
ax1.clause.push_back(x_in_b);
|
||||
theory_axiom* ax1 = alloc(theory_axiom, m, "in-filter");
|
||||
ax1->clause.push_back(m.mk_not(x_in_a));
|
||||
ax1->clause.push_back(x_in_b);
|
||||
m_add_clause(ax1);
|
||||
|
||||
// (x in a) => p(x)
|
||||
theory_axiom ax2(m, "in-filter");
|
||||
ax2.clause.push_back(m.mk_not(x_in_a));
|
||||
ax2.clause.push_back(px);
|
||||
theory_axiom* ax2 = alloc(theory_axiom, m, "in-filter");
|
||||
ax2->clause.push_back(m.mk_not(x_in_a));
|
||||
ax2->clause.push_back(px);
|
||||
m_add_clause(ax2);
|
||||
|
||||
// (x in b) and p(x) => (x in a)
|
||||
theory_axiom ax3(m, "in-filter");
|
||||
ax3.clause.push_back(m.mk_not(x_in_b));
|
||||
ax3.clause.push_back(m.mk_not(px));
|
||||
ax3.clause.push_back(x_in_a);
|
||||
theory_axiom* ax3 = alloc(theory_axiom, m, "in-filter");
|
||||
ax3->clause.push_back(m.mk_not(x_in_b));
|
||||
ax3->clause.push_back(m.mk_not(px));
|
||||
ax3->clause.push_back(x_in_a);
|
||||
m_add_clause(ax3);
|
||||
}
|
||||
|
||||
|
|
@ -280,8 +336,8 @@ void finite_set_axioms::size_singleton_axiom(expr *a) {
|
|||
expr_ref one(arith.mk_int(1), m);
|
||||
expr_ref eq(m.mk_eq(size_a, one), m);
|
||||
|
||||
theory_axiom ax(m, "size-singleton");
|
||||
ax.clause.push_back(eq);
|
||||
theory_axiom* ax = alloc(theory_axiom, m, "size-singleton");
|
||||
ax->clause.push_back(eq);
|
||||
m_add_clause(ax);
|
||||
}
|
||||
|
||||
|
|
@ -293,14 +349,14 @@ void finite_set_axioms::subset_axiom(expr* a) {
|
|||
expr_ref intersect_bc(u.mk_intersect(b, c), m);
|
||||
expr_ref eq(m.mk_eq(intersect_bc, b), m);
|
||||
|
||||
theory_axiom ax1(m, "subset");
|
||||
ax1.clause.push_back(m.mk_not(a));
|
||||
ax1.clause.push_back(eq);
|
||||
theory_axiom* ax1 = alloc(theory_axiom, m, "subset");
|
||||
ax1->clause.push_back(m.mk_not(a));
|
||||
ax1->clause.push_back(eq);
|
||||
m_add_clause(ax1);
|
||||
|
||||
theory_axiom ax2(m, "subset");
|
||||
ax2.clause.push_back(a);
|
||||
ax2.clause.push_back(m.mk_not(eq));
|
||||
theory_axiom* ax2 = alloc(theory_axiom, m, "subset");
|
||||
ax2->clause.push_back(a);
|
||||
ax2->clause.push_back(m.mk_not(eq));
|
||||
m_add_clause(ax2);
|
||||
}
|
||||
|
||||
|
|
@ -313,15 +369,15 @@ void finite_set_axioms::extensionality_axiom(expr *a, expr* b) {
|
|||
expr_ref diff_in_b(u.mk_in(diff_ab, b), m);
|
||||
|
||||
// (a != b) => (x in diff_ab != x in diff_ba)
|
||||
theory_axiom ax(m, "extensionality");
|
||||
ax.clause.push_back(a_eq_b);
|
||||
ax.clause.push_back(m.mk_not(diff_in_a));
|
||||
ax.clause.push_back(m.mk_not(diff_in_b));
|
||||
theory_axiom* ax = alloc(theory_axiom, m, "extensionality");
|
||||
ax->clause.push_back(a_eq_b);
|
||||
ax->clause.push_back(m.mk_not(diff_in_a));
|
||||
ax->clause.push_back(m.mk_not(diff_in_b));
|
||||
m_add_clause(ax);
|
||||
|
||||
theory_axiom ax2(m, "extensionality");
|
||||
ax2.clause.push_back(m.mk_not(a_eq_b));
|
||||
ax2.clause.push_back(diff_in_a);
|
||||
ax2.clause.push_back(diff_in_b);
|
||||
theory_axiom* ax2 = alloc(theory_axiom, m, "extensionality");
|
||||
ax2->clause.push_back(m.mk_not(a_eq_b));
|
||||
ax2->clause.push_back(diff_in_a);
|
||||
ax2->clause.push_back(diff_in_b);
|
||||
m_add_clause(ax2);
|
||||
}
|
||||
|
|
@ -12,6 +12,8 @@ Abstract:
|
|||
|
||||
--*/
|
||||
|
||||
#include "ast/rewriter/th_rewriter.h"
|
||||
|
||||
struct theory_axiom {
|
||||
expr_ref_vector clause;
|
||||
vector<parameter> params;
|
||||
|
|
@ -32,14 +34,15 @@ std::ostream &operator<<(std::ostream &out, theory_axiom const &ax);
|
|||
class finite_set_axioms {
|
||||
ast_manager& m;
|
||||
finite_set_util u;
|
||||
th_rewriter m_rewriter;
|
||||
|
||||
std::function<void(theory_axiom const &)> m_add_clause;
|
||||
std::function<void(theory_axiom *)> m_add_clause;
|
||||
|
||||
public:
|
||||
|
||||
finite_set_axioms(ast_manager &m) : m(m), u(m) {}
|
||||
finite_set_axioms(ast_manager &m) : m(m), u(m), m_rewriter(m) {}
|
||||
|
||||
void set_add_clause(std::function<void(theory_axiom const &)> &ac) {
|
||||
void set_add_clause(std::function<void(theory_axiom*)> &ac) {
|
||||
m_add_clause = ac;
|
||||
}
|
||||
|
||||
|
|
@ -62,10 +65,23 @@ public:
|
|||
// (x in a) <=> (x == b)
|
||||
void in_singleton_axiom(expr *x, expr *a);
|
||||
|
||||
// a := set.singleton(b)
|
||||
// b in a
|
||||
// b-1 not in a
|
||||
// b+1 not in a
|
||||
void in_singleton_axiom(expr *a);
|
||||
|
||||
// a := set.range(lo, hi)
|
||||
// (x in a) <=> (lo <= x <= hi)
|
||||
void in_range_axiom(expr *x, expr *a);
|
||||
|
||||
// a := set.range(lo, hi)
|
||||
// (not (set.in (- lo 1) a))
|
||||
// (not (set.in (+ hi 1) a))
|
||||
// (set.in lo a)
|
||||
// (set.in hi a)
|
||||
void in_range_axiom(expr *a);
|
||||
|
||||
// a := set.map(f, b)
|
||||
// (x in a) <=> set.map_inverse(f, x, b) in b
|
||||
void in_map_axiom(expr *x, expr *a);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue