From 4d20ab64300ba49a923c712106dd2a040fa95bcc Mon Sep 17 00:00:00 2001 From: JustinAJ Date: Sat, 29 Aug 2015 18:47:57 -0400 Subject: [PATCH] Added additional operator+ functions to String classes. --- Jupiter/CString.h | 18 +++++- Jupiter/CString_Imp.h | 144 ++++++++++++++++++++++++++++++++++++++--- Jupiter/String.h | 27 +++++++- Jupiter/String_Imp.h | 145 +++++++++++++++++++++++++++++++++++++++--- Release/Jupiter.lib | Bin 283128 -> 289960 bytes 5 files changed, 311 insertions(+), 23 deletions(-) diff --git a/Jupiter/CString.h b/Jupiter/CString.h index 1ccd787..9980d67 100644 --- a/Jupiter/CString.h +++ b/Jupiter/CString.h @@ -267,12 +267,19 @@ namespace Jupiter CString_Type(const T *in, size_t len); CString_Type(const T *in); - /** Concatenation Constructor */ + /** Concatenation Constructors */ + CString_Type(const Readable_String &lhs, const T &rhs); CString_Type(const Readable_String &lhs, const Readable_String &rhs); + CString_Type(const Readable_String &lhs, const std::basic_string &rhs); + CString_Type(const Readable_String &lhs, const T *rhs); + CString_Type(const Readable_String &lhs, const T *rhs, size_t rhs_size); /** Addition Operators */ + inline CString_Type operator+(const T &rhs) const; inline CString_Type operator+(const CString_Type &rhs) const; inline CString_Type operator+(const Readable_String &rhs) const; + inline CString_Type operator+(const std::basic_string &rhs) const; + inline CString_Type operator+(const T *rhs) const; /** Assignment Operators */ inline CString_Type &operator=(const CString_Type &right) { this->set(right); return *this; }; @@ -470,12 +477,19 @@ namespace Jupiter CString_Loose(const T *in, size_t len); CString_Loose(const T *in); - /** Concatenation Constructor */ + /** Concatenation Constructors */ + CString_Loose(const Readable_String &lhs, const T &rhs); CString_Loose(const Readable_String &lhs, const Readable_String &rhs); + CString_Loose(const Readable_String &lhs, const std::basic_string &rhs); + CString_Loose(const Readable_String &lhs, const T *rhs); + CString_Loose(const Readable_String &lhs, const T *rhs, size_t rhs_size); /** Addition Operators */ + inline CString_Loose operator+(const T &rhs) const; inline CString_Loose operator+(const CString_Loose &rhs) const; inline CString_Loose operator+(const Readable_String &rhs) const; + inline CString_Loose operator+(const std::basic_string &rhs) const; + inline CString_Loose operator+(const T *rhs) const; /** Assignment Operators */ inline CString_Loose &operator=(const CString_Loose &right) { this->set(right); return *this; }; diff --git a/Jupiter/CString_Imp.h b/Jupiter/CString_Imp.h index 9213aba..255e15c 100644 --- a/Jupiter/CString_Imp.h +++ b/Jupiter/CString_Imp.h @@ -108,7 +108,7 @@ template Jupiter::CString_Type::CString_Type(const T *in) } } -template Jupiter::CString_Type::CString_Type(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) : CString_Type(lhs.size() + rhs.size()) +template Jupiter::CString_Type::CString_Type(const Jupiter::Readable_String &lhs, const T &rhs) : CString_Type(lhs.size() + 1) { const T *itr; const T *end; @@ -123,10 +123,44 @@ template Jupiter::CString_Type::CString_Type(const Jupiter::Reada ++Jupiter::String_Type::str; } - if (rhs.isNotEmpty()) + *Jupiter::String_Type::str = rhs; + *++Jupiter::String_Type::str = 0; + + Jupiter::String_Type::length = Jupiter::String_Type::str - Jupiter::Shift_String_Type::base; + Jupiter::String_Type::str = Jupiter::Shift_String_Type::base; +} + +template Jupiter::CString_Type::CString_Type(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) : CString_Type(lhs, rhs.ptr(), rhs.size()) +{ +} + +template Jupiter::CString_Type::CString_Type(const Jupiter::Readable_String &lhs, const std::basic_string &rhs) : CString_Type(lhs, rhs.data(), rhs.size()) +{ +} + +template Jupiter::CString_Type::CString_Type(const Jupiter::Readable_String &lhs, const T *rhs) : CString_Type(lhs, rhs, Jupiter::strlen(rhs)) +{ +} + +template Jupiter::CString_Type::CString_Type(const Jupiter::Readable_String &lhs, const T *rhs, size_t rhs_size) : CString_Type(lhs.size() + rhs_size) +{ + const T *itr; + const T *end; + + if (lhs.isNotEmpty()) + { + itr = lhs.ptr(); + end = itr + lhs.size(); + *Jupiter::String_Type::str = *itr; + while (++itr != end) + *++Jupiter::String_Type::str = *itr; + ++Jupiter::String_Type::str; + } + + if (rhs_size != 0) { - itr = rhs.ptr(); - end = itr + rhs.size(); + itr = rhs; + end = itr + rhs_size; *Jupiter::String_Type::str = *itr; while (++itr != end) *++Jupiter::String_Type::str = *itr; @@ -443,6 +477,11 @@ template size_t Jupiter::CString_Type::concat(const T &in) // Operators +template inline Jupiter::CString_Type Jupiter::CString_Type::operator+(const T &rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + template inline Jupiter::CString_Type Jupiter::CString_Type::operator+(const Jupiter::CString_Type &rhs) const { return Jupiter::CString_Type::operator+(reinterpret_cast &>(rhs)); @@ -453,11 +492,36 @@ template inline Jupiter::CString_Type Jupiter::CString_Type::o return Jupiter::operator+(*this, rhs); } +template inline Jupiter::CString_Type Jupiter::CString_Type::operator+(const std::basic_string &rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + +template inline Jupiter::CString_Type Jupiter::CString_Type::operator+(const T *rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + #if defined JUPITER_CSTRING_TYPE_OPERATOR_PLUS +template static inline Jupiter::CString_Type Jupiter::operator+(const Jupiter::Readable_String &lhs, const T &rhs) +{ + return Jupiter::CString_Type(lhs, rhs); +} + template static inline Jupiter::CString_Type Jupiter::operator+(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) { return Jupiter::CString_Type(lhs, rhs); } + +template static inline Jupiter::CString_Type Jupiter::operator+(const Jupiter::Readable_String &lhs, const std::basic_string &rhs) +{ + return Jupiter::CString_Type(lhs, rhs); +} + +template static inline Jupiter::CString_Type Jupiter::operator+(const Jupiter::Readable_String &lhs, const T *rhs) +{ + return Jupiter::CString_Type(lhs, rhs); +} #endif // JUPITER_CSTRING_TYPE_OPERATOR_PLUS template const Jupiter::CString_Type Jupiter::CString_Type::empty = Jupiter::CString_Type(); @@ -554,7 +618,7 @@ template Jupiter::CString_Loose::CString_Loose(const T *in) : Jup } } -template Jupiter::CString_Loose::CString_Loose(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) : CString_Loose(lhs.size() + rhs.size()) +template Jupiter::CString_Loose::CString_Loose(const Jupiter::Readable_String &lhs, const T &rhs) : CString_Loose(lhs.size() + 1) { const T *itr; const T *end; @@ -569,10 +633,44 @@ template Jupiter::CString_Loose::CString_Loose(const Jupiter::Rea ++Jupiter::String_Type::str; } - if (rhs.isNotEmpty()) + *Jupiter::String_Type::str = rhs; + *++Jupiter::String_Type::str = 0; + + Jupiter::String_Type::length = Jupiter::String_Type::str - Jupiter::Shift_String_Type::base; + Jupiter::String_Type::str = Jupiter::Shift_String_Type::base; +} + +template Jupiter::CString_Loose::CString_Loose(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) : CString_Loose(lhs, rhs.ptr(), rhs.size()) +{ +} + +template Jupiter::CString_Loose::CString_Loose(const Jupiter::Readable_String &lhs, const std::basic_string &rhs) : CString_Loose(lhs, rhs.data(), rhs.size()) +{ +} + +template Jupiter::CString_Loose::CString_Loose(const Jupiter::Readable_String &lhs, const T *rhs) : CString_Loose(lhs, rhs, Jupiter::strlen(rhs)) +{ +} + +template Jupiter::CString_Loose::CString_Loose(const Jupiter::Readable_String &lhs, const T *rhs, size_t rhs_size) : CString_Loose(lhs.size() + rhs_size) +{ + const T *itr; + const T *end; + + if (lhs.isNotEmpty()) { - itr = rhs.ptr(); - end = itr + rhs.size(); + itr = lhs.ptr(); + end = itr + lhs.size(); + *Jupiter::String_Type::str = *itr; + while (++itr != end) + *++Jupiter::String_Type::str = *itr; + ++Jupiter::String_Type::str; + } + + if (rhs_size != 0) + { + itr = rhs; + end = itr + rhs_size; *Jupiter::String_Type::str = *itr; while (++itr != end) *++Jupiter::String_Type::str = *itr; @@ -734,6 +832,11 @@ template typename Jupiter::Readable_String::TokenizeResult inline Jupiter::CString_Loose Jupiter::CString_Loose::operator+(const T &rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + template inline Jupiter::CString_Loose Jupiter::CString_Loose::operator+(const Jupiter::CString_Loose &rhs) const { return Jupiter::CString_Loose::operator+(reinterpret_cast &>(rhs)); @@ -744,11 +847,36 @@ template inline Jupiter::CString_Loose Jupiter::CString_Loose: return Jupiter::operator+(*this, rhs); } +template inline Jupiter::CString_Loose Jupiter::CString_Loose::operator+(const std::basic_string &rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + +template inline Jupiter::CString_Loose Jupiter::CString_Loose::operator+(const T *rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + #if defined JUPITER_CSTRING_LOOSE_OPERATOR_PLUS +template static inline Jupiter::CString_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const T &rhs) +{ + return Jupiter::CString_Loose(lhs, rhs); +} + template static inline Jupiter::CString_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) { return Jupiter::CString_Loose(lhs, rhs); } + +template static inline Jupiter::CString_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const std::basic_string &rhs) +{ + return Jupiter::CString_Loose(lhs, rhs); +} + +template static inline Jupiter::CString_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const T *rhs) +{ + return Jupiter::CString_Loose(lhs, rhs); +} #endif // JUPITER_CSTRING_LOOSE_OPERATOR_PLUS template const Jupiter::CString_Loose Jupiter::CString_Loose::empty = Jupiter::CString_Loose(); diff --git a/Jupiter/String.h b/Jupiter/String.h index 26c6650..a3442f2 100644 --- a/Jupiter/String.h +++ b/Jupiter/String.h @@ -246,12 +246,19 @@ namespace Jupiter String_Strict(const T *in); String_Strict(const Jupiter::DataBuffer &in); - /** Concatenation Constructor */ + /** Concatenation Constructors */ + String_Strict(const Readable_String &lhs, const T &rhs); String_Strict(const Readable_String &lhs, const Readable_String &rhs); + String_Strict(const Readable_String &lhs, const std::basic_string &rhs); + String_Strict(const Readable_String &lhs, const T *rhs); + String_Strict(const Readable_String &lhs, const T *rhs, size_t rhs_size); /** Addition Operators */ + inline String_Strict operator+(const T &rhs) const; inline String_Strict operator+(const String_Strict &rhs) const; inline String_Strict operator+(const Readable_String &rhs) const; + inline String_Strict operator+(const std::basic_string &rhs) const; + inline String_Strict operator+(const T *rhs) const; /** Assignment Operators */ inline String_Strict &operator=(const String_Strict &right) { this->set(right); return *this; }; @@ -269,8 +276,12 @@ namespace Jupiter }; #if defined JUPITER_STRING_STRICT_OPERATOR_PLUS - /** String_Loose Addition Operator */ + /** String_Loose Addition Operators */ + template static inline Jupiter::String_Strict operator+(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs); + template static inline Jupiter::String_Strict operator+(const Jupiter::Readable_String &lhs, const T &rhs); template static inline Jupiter::String_Strict operator+(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs); + template static inline Jupiter::String_Strict operator+(const Jupiter::Readable_String &lhs, const std::basic_string &rhs); + template static inline Jupiter::String_Strict operator+(const Jupiter::Readable_String &lhs, const T *rhs); #endif // JUPITER_STRING_STRICT_OPERATOR_PLUS /** @@ -512,12 +523,19 @@ namespace Jupiter String_Loose(const T *in); String_Loose(const Jupiter::DataBuffer &in); - /** Concatenation Constructor */ + /** Concatenation Constructors */ + String_Loose(const Readable_String &lhs, const T &rhs); String_Loose(const Readable_String &lhs, const Readable_String &rhs); + String_Loose(const Readable_String &lhs, const std::basic_string &rhs); + String_Loose(const Readable_String &lhs, const T *rhs); + String_Loose(const Readable_String &lhs, const T *rhs, size_t rhs_size); /** Addition Operators */ + inline String_Loose operator+(const T &rhs) const; inline String_Loose operator+(const String_Loose &rhs) const; inline String_Loose operator+(const Readable_String &rhs) const; + inline String_Loose operator+(const std::basic_string &rhs) const; + inline String_Loose operator+(const T *rhs) const; /** Assignment Operators */ inline String_Loose &operator=(const String_Loose &right) { this->set(right); return *this; }; @@ -539,7 +557,10 @@ namespace Jupiter #if !defined JUPITER_STRING_STRICT_OPERATOR_PLUS #if !defined DISABLE_DEFAULT_JUPITER_STRING_OPERATOR_PLUS /** String_Loose Addition Operator */ + template static inline Jupiter::String_Loose operator+(const Jupiter::Readable_String &lhs, const T &rhs); template static inline Jupiter::String_Loose operator+(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs); + template static inline Jupiter::String_Loose operator+(const Jupiter::Readable_String &lhs, const std::basic_string &rhs); + template static inline Jupiter::String_Loose operator+(const Jupiter::Readable_String &lhs, const T *rhs); #endif // DISABLE_DEFAULT_JUPITER_STRING_OPERATOR_PLUS #endif // JUPITER_STRING_STRICT_OPERATOR_PLUS diff --git a/Jupiter/String_Imp.h b/Jupiter/String_Imp.h index bd45b86..f644984 100644 --- a/Jupiter/String_Imp.h +++ b/Jupiter/String_Imp.h @@ -105,7 +105,7 @@ template Jupiter::String_Strict::String_Strict(const Jupiter::Dat { } -template Jupiter::String_Strict::String_Strict(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) : String_Strict(lhs.size() + rhs.size()) +template Jupiter::String_Strict::String_Strict(const Jupiter::Readable_String &lhs, const T &rhs) : String_Strict(lhs.size() + 1) { const T *itr; const T *end; @@ -120,10 +120,43 @@ template Jupiter::String_Strict::String_Strict(const Jupiter::Rea ++Jupiter::String_Type::str; } - if (rhs.isNotEmpty()) + *Jupiter::String_Type::str = rhs; + + Jupiter::String_Type::length = Jupiter::String_Type::str - Jupiter::Shift_String_Type::base + 1; + Jupiter::String_Type::str = Jupiter::Shift_String_Type::base; +} + +template Jupiter::String_Strict::String_Strict(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) : String_Strict(lhs, rhs.ptr(), rhs.size()) +{ +} + +template Jupiter::String_Strict::String_Strict(const Jupiter::Readable_String &lhs, const std::basic_string &rhs) : String_Strict(lhs, rhs.data(), rhs.size()) +{ +} + +template Jupiter::String_Strict::String_Strict(const Jupiter::Readable_String &lhs, const T *rhs) : String_Strict(lhs, rhs, Jupiter::strlen(rhs)) +{ +} + +template Jupiter::String_Strict::String_Strict(const Jupiter::Readable_String &lhs, const T *rhs, size_t rhs_size) : String_Strict(lhs.size() + rhs_size) +{ + const T *itr; + const T *end; + + if (lhs.isNotEmpty()) + { + itr = lhs.ptr(); + end = itr + lhs.size(); + *Jupiter::String_Type::str = *itr; + while (++itr != end) + *++Jupiter::String_Type::str = *itr; + ++Jupiter::String_Type::str; + } + + if (rhs_size != 0) { - itr = rhs.ptr(); - end = itr + rhs.size(); + itr = rhs; + end = itr + rhs_size; *Jupiter::String_Type::str = *itr; while (++itr != end) *++Jupiter::String_Type::str = *itr; @@ -349,6 +382,11 @@ template typename Jupiter::Readable_String::TokenizeResult inline Jupiter::String_Strict Jupiter::String_Strict::operator+(const T &rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + template inline Jupiter::String_Strict Jupiter::String_Strict::operator+(const Jupiter::String_Strict &rhs) const { return Jupiter::String_Strict::operator+(reinterpret_cast &>(rhs)); @@ -359,11 +397,36 @@ template inline Jupiter::String_Strict Jupiter::String_Strict: return Jupiter::operator+(*this, rhs); } +template inline Jupiter::String_Strict Jupiter::String_Strict::operator+(const std::basic_string &rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + +template inline Jupiter::String_Strict Jupiter::String_Strict::operator+(const T *rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + #if defined JUPITER_STRING_STRICT_OPERATOR_PLUS +template static inline Jupiter::String_Strict Jupiter::operator+(const Jupiter::Readable_String &lhs, const T &rhs) +{ + return Jupiter::String_Strict(lhs, rhs); +} + template static inline Jupiter::String_Strict Jupiter::operator+(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) { return Jupiter::String_Strict(lhs, rhs); } + +template static inline Jupiter::String_Strict Jupiter::operator+(const Jupiter::Readable_String &lhs, const std::basic_string &rhs) +{ + return Jupiter::String_Strict(lhs, rhs); +} + +template static inline Jupiter::String_Strict Jupiter::operator+(const Jupiter::Readable_String &lhs, const T *rhs) +{ + return Jupiter::String_Strict(lhs, rhs); +} #endif // JUPITER_STRING_STRICT_OPERATOR_PLUS template const Jupiter::String_Strict Jupiter::String_Strict::empty = Jupiter::String_Strict(); @@ -434,8 +497,7 @@ template Jupiter::String_Loose::String_Loose(const T *in, size_t while (Jupiter::String_Type::length != len) { Jupiter::String_Type::str[Jupiter::String_Type::length] = *in; - Jupiter::String_Type::length++; - in++; + ++in, ++Jupiter::String_Type::length; } } @@ -465,7 +527,40 @@ template Jupiter::String_Loose::String_Loose(const Jupiter::DataB { } -template Jupiter::String_Loose::String_Loose(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) : String_Loose(lhs.size() + rhs.size()) +template Jupiter::String_Loose::String_Loose(const Jupiter::Readable_String &lhs, const T &rhs) : String_Loose(lhs.size() + 1) +{ + const T *itr; + const T *end; + + if (lhs.isNotEmpty()) + { + itr = lhs.ptr(); + end = itr + lhs.size(); + *Jupiter::String_Type::str = *itr; + while (++itr != end) + *++Jupiter::String_Type::str = *itr; + ++Jupiter::String_Type::str; + } + + *Jupiter::String_Type::str = rhs; + + Jupiter::String_Type::length = Jupiter::String_Type::str - Jupiter::Shift_String_Type::base + 1; + Jupiter::String_Type::str = Jupiter::Shift_String_Type::base; +} + +template Jupiter::String_Loose::String_Loose(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) : String_Loose(lhs, rhs.ptr(), rhs.size()) +{ +} + +template Jupiter::String_Loose::String_Loose(const Jupiter::Readable_String &lhs, const std::basic_string &rhs) : String_Loose(lhs, rhs.data(), rhs.size()) +{ +} + +template Jupiter::String_Loose::String_Loose(const Jupiter::Readable_String &lhs, const T *rhs) : String_Loose(lhs, rhs, Jupiter::strlen(rhs)) +{ +} + +template Jupiter::String_Loose::String_Loose(const Jupiter::Readable_String &lhs, const T *rhs, size_t rhs_size) : String_Loose(lhs.size() + rhs_size) { const T *itr; const T *end; @@ -480,10 +575,10 @@ template Jupiter::String_Loose::String_Loose(const Jupiter::Reada ++Jupiter::String_Type::str; } - if (rhs.isNotEmpty()) + if (rhs_size != 0) { - itr = rhs.ptr(); - end = itr + rhs.size(); + itr = rhs; + end = itr + rhs_size; *Jupiter::String_Type::str = *itr; while (++itr != end) *++Jupiter::String_Type::str = *itr; @@ -692,6 +787,11 @@ template Jupiter::String_Loose Jupiter::String_Loose::gotoToke // Operators +template inline Jupiter::String_Loose Jupiter::String_Loose::operator+(const T &rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + template inline Jupiter::String_Loose Jupiter::String_Loose::operator+(const Jupiter::String_Loose &rhs) const { return Jupiter::String_Loose::operator+(reinterpret_cast &>(rhs)); @@ -702,6 +802,16 @@ template inline Jupiter::String_Loose Jupiter::String_Loose::o return Jupiter::operator+(*this, rhs); } +template inline Jupiter::String_Loose Jupiter::String_Loose::operator+(const std::basic_string &rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + +template inline Jupiter::String_Loose Jupiter::String_Loose::operator+(const T *rhs) const +{ + return Jupiter::operator+(*this, rhs); +} + // tokenize template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Loose::tokenize(const T &separator) @@ -736,10 +846,25 @@ template typename Jupiter::Readable_String::TokenizeResult static inline Jupiter::String_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const T &rhs) +{ + return Jupiter::String_Loose(lhs, rhs); +} + template static inline Jupiter::String_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) { return Jupiter::String_Loose(lhs, rhs); } + +template static inline Jupiter::String_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const std::basic_string &rhs) +{ + return Jupiter::String_Loose(lhs, rhs); +} + +template static inline Jupiter::String_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const T *rhs) +{ + return Jupiter::String_Loose(lhs, rhs); +} #endif // DISABLE_DEFAULT_JUPITER_STRING_OPERATOR_PLUS #endif // JUPITER_STRING_STRICT_OPERATOR_PLUS diff --git a/Release/Jupiter.lib b/Release/Jupiter.lib index 789b03142f63ff5bd16dab3789fb003338f14816..cd8fef0eeb942a12a6708642f46df62d888621eb 100644 GIT binary patch delta 39544 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 delta 38589 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 AdjJ3c