diff --git a/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_common.h b/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_common.h new file mode 100644 index 0000000000000000000000000000000000000000..4c43612cd89d3aa3b77083198081284b3011fb65 --- /dev/null +++ b/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_common.h @@ -0,0 +1,257 @@ + /* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FOUNDATION_ACE_TEST_UNITTEST_CORE_PATTERN_RICH_EDITOR_RICH_EDITOR_ONWILL_TEST_COMMON_H +#define FOUNDATION_ACE_TEST_UNITTEST_CORE_PATTERN_RICH_EDITOR_RICH_EDITOR_ONWILL_TEST_COMMON_H + +#include "test/unittest/core/pattern/rich_editor/rich_editor_common_test_ng.h" +#include "test/unittest/core/pattern/rich_editor/rich_editor_recursive_macro.h" +#include "test/mock/core/render/mock_paragraph.h" +#include "test/mock/core/pipeline/mock_pipeline_context.h" +#include "test/mock/core/common/mock_container.h" +#include "test/mock/base/mock_task_executor.h" +#include "core/components_ng/pattern/rich_editor/rich_editor_model_ng.h" + +#define GENERATE_CASES(num, OP) EXPAND_##num(OP, num) + +#define CREATE_INSERT_CASE(testSuite, cases, number) \ +HWTEST_F(testSuite, testSuite##number, TestSize.Level1) \ +{ \ + ASSERT_NE(richEditorNode_, nullptr); \ + auto pattern = richEditorNode_->GetPattern(); \ + ASSERT_NE(pattern, nullptr); \ + const auto& testCase = (cases)[std::atoi(#number)]; \ + const auto& input = testCase.first; \ + const auto& expectOutput = testCase.second; \ + ASSERT_TRUE(pattern->caretPosition_ != -1 || (input.selector.start != -1 && input.selector.end != -1)); \ + InitSpans(input.spans); \ + if (input.caret != -1) { \ + pattern->caretPosition_ = input.caret; \ + } else { \ + pattern->UpdateSelector(input.selector.start, input.selector.end); \ + pattern->caretPosition_ = input.selector.start; \ + } \ + InitContentChangeCallback(); \ + pattern->InsertValue(INSERT_VALUE); \ + EXPECT_EQ(isOnWillChangeCalled, true); \ + ASSERT_EQ(onWillReplacedSpans.size(), 1); \ + auto& replacedSpan = onWillReplacedSpans.front(); \ + EXPECT_EQ(onWillRangeBefore, expectOutput.rangeBefore); \ + EXPECT_EQ(replacedSpan.GetSpanIndex(), expectOutput.spanIndex); \ + EXPECT_EQ(replacedSpan.OffsetInSpan(), expectOutput.rangeInSpan.start); \ + EXPECT_EQ(replacedSpan.GetEraseLength(), expectOutput.rangeInSpan.end - expectOutput.rangeInSpan.start); \ + EXPECT_EQ(replacedSpan.GetSpanRangeStart(), expectOutput.spanRange.start); \ + EXPECT_EQ(replacedSpan.GetSpanRangeEnd(), expectOutput.spanRange.end); \ + EXPECT_EQ(replacedSpan.GetValue(), expectOutput.value); \ +} + +namespace OHOS::Ace::NG { +enum class SpanType { + TEXT, + SYMBOL, + IMAGE, + BUILDER +}; +struct ReplacedSpanInfo { + TextRange rangeBefore; + int32_t spanIndex; + TextRange rangeInSpan; + TextRange spanRange; + std::u16string value; +}; +struct InputInfo { + std::string spans; + int32_t caret = -1; + TextRange selector; +}; +namespace { +bool isOnWillChangeCalled = false; +bool isOnDidChangeCalled = false; +RichEditorChangeValue onWillChangeValue; +RichEditorChangeValue onDidChangeValue; +auto& onWillRangeBefore = onWillChangeValue.rangeBefore_; +auto& onWillReplacedSpans = onWillChangeValue.replacedSpans_; + +std::u16string INSERT_VALUE = u"A"; +const auto BUILDER_NODE_1 = FrameNode::GetOrCreateFrameNode(V2::ROW_ETS_TAG, + ElementRegister::GetInstance()->MakeUniqueId(), + []() { return AceType::MakeRefPtr(false); }); +const TextSpanOptions TEXT_SPAN_OPTIONS = { .value = u"abc", .style = TEXT_STYLE_1 }; +const std::unordered_map)>> SPAN_CONSTRUCTOR_MAP = { + { SpanType::TEXT, [](RefPtr pattern) { pattern->AddTextSpan(TEXT_SPAN_OPTIONS);} }, + { SpanType::IMAGE, [](RefPtr pattern) { pattern->AddImageSpan(IMAGE_SPAN_OPTIONS_1);} }, + { SpanType::SYMBOL, [](RefPtr pattern) { pattern->AddSymbolSpan(SYMBOL_SPAN_OPTIONS_1);} }, + { SpanType::BUILDER, [](RefPtr pattern) { pattern->AddPlaceholderSpan(BUILDER_NODE_1, {});} } +}; + +const std::vector SPAN_KEY_WORDS = {"[IMAGE]", "[BUILDER]", "[SYMBOL]"}; +const std::unordered_map)>> SPAN_ADDER_MAP = { + { SPAN_KEY_WORDS[0], [](RefPtr pattern) { pattern->AddImageSpan(IMAGE_SPAN_OPTIONS_1);} }, + { SPAN_KEY_WORDS[1], [](RefPtr pattern) { pattern->AddPlaceholderSpan(BUILDER_NODE_1, {});} }, + { SPAN_KEY_WORDS[2], [](RefPtr pattern) { pattern->AddSymbolSpan(SYMBOL_SPAN_OPTIONS_1);} }, +}; + +class SpanStringSpliter { +public: +static std::vector SplitSpanString(const std::string& str) +{ + auto parts = SplitByPipe(str); + return SplitString(parts); +} +private: +static std::vector SplitByPipe(const std::string& str) +{ + std::vector parts; + std::regex pattern(R"([^|]+)"); + std::sregex_iterator it(str.begin(), str.end(), pattern); + std::sregex_iterator end; + for (; it != end; ++it) { + parts.push_back(it->str()); + } + return parts; +} + +static std::vector SplitString(const std::string& str) { + std::vector result; + std::string current_str; + int i = 0; + int n = str.size(); + while (i < n) { + if (str[i] == '\n') { + current_str += '\n'; + result.push_back(current_str); + current_str.clear(); + i++; + continue; + } + bool found = false; + for (const auto& kw : SPAN_KEY_WORDS) { + int kw_len = kw.size(); + CHECK_NULL_CONTINUE(i + kw_len <= n && str.substr(i, kw_len) == kw); + if (!current_str.empty()) { + result.push_back(current_str); + current_str.clear(); + } + result.push_back(kw); + i += kw_len; + found = true; + break; + } + CHECK_NULL_CONTINUE(!found); + current_str += str[i]; + i++; + } + if (!current_str.empty()) { + result.push_back(current_str); + } + return result; +} + +static std::vector SplitString(std::vector& parts) +{ + std::vector result; + for (auto& part : parts) { + auto partResult = SplitString(part); + result.insert(result.end(), partResult.begin(), partResult.end()); + } + return result; +} +}; + +} // namespace + +class RichEditorOnWillTestCommon : public RichEditorCommonTestNg { +public: + void SetUp() override + { + MockPipelineContext::SetUp(); + MockContainer::SetUp(); + MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr(); + auto* stack = ViewStackProcessor::GetInstance(); + auto nodeId = stack->ClaimNodeId(); + richEditorNode_ = FrameNode::GetOrCreateFrameNode( + V2::RICH_EDITOR_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr(); }); + ASSERT_NE(richEditorNode_, nullptr); + auto pattern = richEditorNode_->GetPattern(); + pattern->SetRichEditorController(AceType::MakeRefPtr()); + pattern->GetRichEditorController()->SetPattern(AceType::WeakClaim(AceType::RawPtr(pattern))); + } + + void TearDown() override + { + richEditorNode_ = nullptr; + MockParagraph::TearDown(); + } + + static void TearDownTestSuite() + { + TestNG::TearDownTestSuite(); + } +protected: + void ResetContentChangeCallbackState() + { + isOnWillChangeCalled = false; + isOnDidChangeCalled = false; + onWillChangeValue.reset(); + onDidChangeValue.reset(); + } + + void InitContentChangeCallback() + { + ResetContentChangeCallbackState(); + auto onWillChange = [](const RichEditorChangeValue& changeValue) { + isOnWillChangeCalled = true; + onWillChangeValue = changeValue; + return true; + }; + RichEditorModelNG::SetOnWillChange(AceType::RawPtr(richEditorNode_), std::move(onWillChange)); + + auto onDidChange = [](const RichEditorChangeValue& changeValue) { + isOnDidChangeCalled = true; + onDidChangeValue = changeValue; + }; + RichEditorModelNG::SetOnDidChange(AceType::RawPtr(richEditorNode_), std::move(onDidChange)); + } + + void InitSpans(const std::vector& spanTypes) + { + RichEditorCommonTestNg::ClearSpan(); + auto pattern = richEditorNode_->GetPattern(); + for (const auto& spanType : spanTypes) { + auto it = SPAN_CONSTRUCTOR_MAP.find(spanType); + (it->second)(pattern); + } + } + + void InitSpans(const std::string& spanString) + { + RichEditorCommonTestNg::ClearSpan(); + std::vector spans = SpanStringSpliter::SplitSpanString(spanString); + auto pattern = richEditorNode_->GetPattern(); + for (const auto& span : spans) { + auto it = SPAN_ADDER_MAP.find(span); + if (it != SPAN_ADDER_MAP.end()) { + (it->second)(pattern); + continue; + } + TextSpanOptions options = { .value = StringUtils::Str8ToStr16(span), .style = TEXT_STYLE_1 }; + pattern->AddTextSpan(options); + } + } +}; + +} // namespace OHOS::Ace + +#endif // FOUNDATION_ACE_TEST_UNITTEST_CORE_PATTERN_RICH_EDITOR_RICH_EDITOR_ONWILL_TEST_COMMON_H \ No newline at end of file diff --git a/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_normal_insert.cpp b/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_normal_insert.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8364796858f344882e2c11b825e8bab40d1506e2 --- /dev/null +++ b/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_normal_insert.cpp @@ -0,0 +1,85 @@ + /* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_common.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS::Ace::NG { +namespace { +std::pair NORMAL_INSERT_CASES[] = { + {{ .spans = "abc|abc", .caret = 0}, /* 0 */ + {.rangeBefore = { 0, 0 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "abc|abc", .caret = 1}, /* 1 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 4 }, .value = u"aAbc"}}, + {{ .spans = "abc|abc", .caret = 3}, /* 2 */ + {.rangeBefore = { 3, 3 }, .spanIndex = 0, .rangeInSpan = { 3, 4 }, .spanRange = { 0, 4 }, .value = u"abcA"}}, + {{ .spans = "abc|abc", .caret = 4}, /* 3 */ + {.rangeBefore = { 4, 4 }, .spanIndex = 1, .rangeInSpan = { 1, 2 }, .spanRange = { 3, 7 }, .value = u"aAbc"}}, + {{ .spans = "abc|abc", .caret = 6}, /* 4 */ + {.rangeBefore = { 6, 6 }, .spanIndex = 1, .rangeInSpan = { 3, 4 }, .spanRange = { 3, 7 }, .value = u"abcA"}}, + {{ .spans = "[IMAGE][IMAGE]", .caret = 0}, /* 5 */ + {.rangeBefore = { 0, 0 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[IMAGE][IMAGE]", .caret = 1}, /* 6 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[IMAGE][IMAGE]", .caret = 2}, /* 7 */ + {.rangeBefore = { 2, 2 }, .spanIndex = 2, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 3 }, .value = u"A"}}, + {{ .spans = "[BUILDER][BUILDER]", .caret = 0}, /* 8 */ + {.rangeBefore = { 0, 0 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[BUILDER][BUILDER]", .caret = 1}, /* 9 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[BUILDER][BUILDER]", .caret = 2}, /* 10 */ + {.rangeBefore = { 2, 2 }, .spanIndex = 2, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 3 }, .value = u"A"}}, + {{ .spans = "[SYMBOL][SYMBOL]", .caret = 0}, /* 11 */ + {.rangeBefore = { 0, 0 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[SYMBOL][SYMBOL]", .caret = 2}, /* 12 */ + {.rangeBefore = { 2, 2 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 3 }, .value = u"A"}}, + {{ .spans = "[SYMBOL][SYMBOL]", .caret = 4}, /* 13 */ + {.rangeBefore = { 4, 4 }, .spanIndex = 2, .rangeInSpan = { 0, 1 }, .spanRange = { 4, 5 }, .value = u"A"}}, + {{ .spans = "abc[IMAGE]", .caret = 3}, /* 14 */ + {.rangeBefore = { 3, 3 }, .spanIndex = 0, .rangeInSpan = { 3, 4 }, .spanRange = { 0, 4 }, .value = u"abcA"}}, + {{ .spans = "abc[BUILDER]", .caret = 3}, /* 15 */ + {.rangeBefore = { 3, 3 }, .spanIndex = 0, .rangeInSpan = { 3, 4 }, .spanRange = { 0, 4 }, .value = u"abcA"}}, + {{ .spans = "abc[SYMBOL]", .caret = 3}, /* 16 */ + {.rangeBefore = { 3, 3 }, .spanIndex = 0, .rangeInSpan = { 3, 4 }, .spanRange = { 0, 4 }, .value = u"abcA"}}, + {{ .spans = "[IMAGE]abc", .caret = 1}, /* 17 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 5 }, .value = u"Aabc"}}, + {{ .spans = "[IMAGE][BUILDER]", .caret = 1}, /* 18 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[IMAGE][SYMBOL]", .caret = 1}, /* 19 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[BUILDER]abc", .caret = 1}, /* 20 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 5 }, .value = u"Aabc"}}, + {{ .spans = "[BUILDER][IMAGE]", .caret = 1}, /* 21 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[BUILDER][SYMBOL]", .caret = 1}, /* 22 */ + {.rangeBefore = { 1, 1 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[SYMBOL]abc", .caret = 2}, /* 23 */ + {.rangeBefore = { 2, 2 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 6 }, .value = u"Aabc"}}, + {{ .spans = "[SYMBOL][IMAGE]", .caret = 2}, /* 24 */ + {.rangeBefore = { 2, 2 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 3 }, .value = u"A"}}, + {{ .spans = "[SYMBOL][BUILDER]", .caret = 2}, /* 25 */ + {.rangeBefore = { 2, 2 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 3 }, .value = u"A"}}, +}; +} // namespace + +class RichEditorOnWillTestNormalInsert : public RichEditorOnWillTestCommon {}; + +#define CREATE_NORMAL_INSERT_CASE(number) \ + CREATE_INSERT_CASE(RichEditorOnWillTestNormalInsert, NORMAL_INSERT_CASES, number) + +GENERATE_CASES(26, CREATE_NORMAL_INSERT_CASE); +} \ No newline at end of file diff --git a/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_replace_insert.cpp b/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_replace_insert.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0112eb2984c35ab02dce0ef45a65de07183611ff --- /dev/null +++ b/test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_replace_insert.cpp @@ -0,0 +1,195 @@ + /* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "test/unittest/core/pattern/rich_editor/rich_editor_onwill_test_common.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS::Ace::NG { +namespace { +std::pair REPLACE_INSERT_CASES[] = { + {{ .spans = "abc|abc|abc", .selector = { 0, 1 }}, /* 0 */ + {.rangeBefore = { 0, 1 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "abc|abc|abc", .selector = { 0, 2 }}, /* 1 */ + {.rangeBefore = { 0, 2 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 2 }, .value = u"Ac"}}, + {{ .spans = "abc|abc|abc", .selector = { 0, 3 }}, /* 2 */ + {.rangeBefore = { 0, 3 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "abc|abc|abc", .selector = { 0, 4 }}, /* 3 */ + {.rangeBefore = { 0, 4 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "abc|abc|abc", .selector = { 0, 5 }}, /* 4 */ + {.rangeBefore = { 0, 5 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 2 }, .value = u"Ac"}}, + {{ .spans = "abc|abc|abc", .selector = { 0, 6 }}, /* 5 */ + {.rangeBefore = { 0, 6 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "abc|abc|abc", .selector = { 0, 7 }}, /* 6 */ + {.rangeBefore = { 0, 7 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "abc|abc|abc", .selector = { 1, 2 }}, /* 7 */ + {.rangeBefore = { 1, 2 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 3 }, .value = u"aAc"}}, + {{ .spans = "abc|abc|abc", .selector = { 1, 3 }}, /* 8 */ + {.rangeBefore = { 1, 3 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc|abc|abc", .selector = { 1, 4 }}, /* 9 */ + {.rangeBefore = { 1, 4 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc|abc|abc", .selector = { 1, 6 }}, /* 10 */ + {.rangeBefore = { 1, 6 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc|abc|abc", .selector = { 1, 7 }}, /* 11 */ + {.rangeBefore = { 1, 7 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + + {{ .spans = "[IMAGE]abc|abc", .selector = { 0, 1 }}, /* 12 */ + {.rangeBefore = { 0, 1 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "[IMAGE]abc|abc", .selector = { 0, 2 }}, /* 13 */ + {.rangeBefore = { 0, 2 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "[IMAGE]abc|abc", .selector = { 0, 4 }}, /* 14 */ + {.rangeBefore = { 0, 4 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "[IMAGE]abc|abc", .selector = { 0, 5 }}, /* 15 */ + {.rangeBefore = { 0, 5 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "[IMAGE]abc|abc", .selector = { 0, 7 }}, /* 16 */ + {.rangeBefore = { 0, 7 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[IMAGE]abc|abc", .selector = { 1, 2 }}, /* 17 */ + {.rangeBefore = { 1, 2 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 4 }, .value = u"Abc"}}, + {{ .spans = "[IMAGE]abc|abc", .selector = { 1, 4 }}, /* 18 */ + {.rangeBefore = { 1, 4 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 5 }, .value = u"Aabc"}}, + {{ .spans = "[IMAGE]abc|abc", .selector = { 1, 5 }}, /* 19 */ + {.rangeBefore = { 1, 5 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 4 }, .value = u"Abc"}}, + + {{ .spans = "[SYMBOL]abc|abc", .selector = { 0, 2 }}, /* 20 */ + {.rangeBefore = { 0, 2 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "[SYMBOL]abc|abc", .selector = { 0, 3 }}, /* 21 */ + {.rangeBefore = { 0, 3 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "[SYMBOL]abc|abc", .selector = { 0, 5 }}, /* 22 */ + {.rangeBefore = { 0, 5 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "[SYMBOL]abc|abc", .selector = { 0, 6 }}, /* 23 */ + {.rangeBefore = { 0, 6 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "[SYMBOL]abc|abc", .selector = { 0, 8 }}, /* 24 */ + {.rangeBefore = { 0, 8 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[SYMBOL]abc|abc", .selector = { 2, 3 }}, /* 25 */ + {.rangeBefore = { 2, 3 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 5 }, .value = u"Abc"}}, + {{ .spans = "[SYMBOL]abc|abc", .selector = { 2, 5 }}, /* 26 */ + {.rangeBefore = { 2, 5 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 6 }, .value = u"Aabc"}}, + {{ .spans = "[SYMBOL]abc|abc", .selector = { 2, 6 }}, /* 27 */ + {.rangeBefore = { 2, 6 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 5 }, .value = u"Abc"}}, + + {{ .spans = "abc[IMAGE]abc", .selector = { 0, 1 }}, /* 28 */ + {.rangeBefore = { 0, 1 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 0, 3 }}, /* 29 */ + {.rangeBefore = { 0, 3 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 0, 4 }}, /* 30 */ + {.rangeBefore = { 0, 4 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 0, 5 }}, /* 31 */ + {.rangeBefore = { 0, 5 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 1, 2 }}, /* 32 */ + {.rangeBefore = { 1, 2 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 3 }, .value = u"aAc"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 1, 3 }}, /* 33 */ + {.rangeBefore = { 1, 3 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 1, 4 }}, /* 34 */ + {.rangeBefore = { 1, 4 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 1, 5 }}, /* 35 */ + {.rangeBefore = { 1, 5 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 2, 3 }}, /* 36 */ + {.rangeBefore = { 2, 3 }, .spanIndex = 0, .rangeInSpan = { 2, 3 }, .spanRange = { 0, 3 }, .value = u"abA"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 2, 4 }}, /* 37 */ + {.rangeBefore = { 2, 4 }, .spanIndex = 0, .rangeInSpan = { 2, 3 }, .spanRange = { 0, 3 }, .value = u"abA"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 2, 5 }}, /* 38 */ + {.rangeBefore = { 2, 5 }, .spanIndex = 0, .rangeInSpan = { 2, 3 }, .spanRange = { 0, 3 }, .value = u"abA"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 3, 4 }}, /* 39 */ + {.rangeBefore = { 3, 4 }, .spanIndex = 0, .rangeInSpan = { 3, 4 }, .spanRange = { 0, 4 }, .value = u"abcA"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 3, 5 }}, /* 40 */ + {.rangeBefore = { 3, 5 }, .spanIndex = 0, .rangeInSpan = { 3, 4 }, .spanRange = { 0, 4 }, .value = u"abcA"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 4, 5 }}, /* 41 */ + {.rangeBefore = { 4, 5 }, .spanIndex = 2, .rangeInSpan = { 0, 1 }, .spanRange = { 4, 7 }, .value = u"Abc"}}, + {{ .spans = "abc[IMAGE]abc", .selector = { 4, 7 }}, /* 42 */ + {.rangeBefore = { 4, 7 }, .spanIndex = 2, .rangeInSpan = { 0, 1 }, .spanRange = { 4, 5 }, .value = u"A"}}, + + {{ .spans = "abc[SYMBOL]abc", .selector = { 0, 1 }}, /* 43 */ + {.rangeBefore = { 0, 1 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 0, 3 }}, /* 44 */ + {.rangeBefore = { 0, 3 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 0, 5 }}, /* 45 */ + {.rangeBefore = { 0, 5 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 0, 6 }}, /* 46 */ + {.rangeBefore = { 0, 6 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 1, 2 }}, /* 47 */ + {.rangeBefore = { 1, 2 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 3 }, .value = u"aAc"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 1, 3 }}, /* 48 */ + {.rangeBefore = { 1, 3 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 1, 5 }}, /* 49 */ + {.rangeBefore = { 1, 5 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 1, 6 }}, /* 50 */ + {.rangeBefore = { 1, 6 }, .spanIndex = 0, .rangeInSpan = { 1, 2 }, .spanRange = { 0, 2 }, .value = u"aA"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 2, 3 }}, /* 51 */ + {.rangeBefore = { 2, 3 }, .spanIndex = 0, .rangeInSpan = { 2, 3 }, .spanRange = { 0, 3 }, .value = u"abA"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 2, 5 }}, /* 52 */ + {.rangeBefore = { 2, 5 }, .spanIndex = 0, .rangeInSpan = { 2, 3 }, .spanRange = { 0, 3 }, .value = u"abA"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 2, 6 }}, /* 53 */ + {.rangeBefore = { 2, 6 }, .spanIndex = 0, .rangeInSpan = { 2, 3 }, .spanRange = { 0, 3 }, .value = u"abA"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 3, 5 }}, /* 54 */ + {.rangeBefore = { 3, 5 }, .spanIndex = 0, .rangeInSpan = { 3, 4 }, .spanRange = { 0, 4 }, .value = u"abcA"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 3, 6 }}, /* 55 */ + {.rangeBefore = { 3, 6 }, .spanIndex = 0, .rangeInSpan = { 3, 4 }, .spanRange = { 0, 4 }, .value = u"abcA"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 5, 6 }}, /* 56 */ + {.rangeBefore = { 5, 6 }, .spanIndex = 2, .rangeInSpan = { 0, 1 }, .spanRange = { 5, 8 }, .value = u"Abc"}}, + {{ .spans = "abc[SYMBOL]abc", .selector = { 5, 8 }}, /* 57 */ + {.rangeBefore = { 5, 8 }, .spanIndex = 2, .rangeInSpan = { 0, 1 }, .spanRange = { 5, 6 }, .value = u"A"}}, + + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 0, 1 }}, /* 58 */ + {.rangeBefore = { 0, 1 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 4 }, .value = u"Aabc"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 0, 2 }}, /* 59 */ + {.rangeBefore = { 0, 2 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 3 }, .value = u"Abc"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 0, 4 }}, /* 60 */ + {.rangeBefore = { 0, 4 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 0, 5 }}, /* 61 */ + {.rangeBefore = { 0, 5 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 1, 2 }}, /* 62 */ + {.rangeBefore = { 1, 2 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 4 }, .value = u"Abc"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 1, 4 }}, /* 63 */ + {.rangeBefore = { 1, 4 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 1, 5 }}, /* 64 */ + {.rangeBefore = { 1, 5 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 2, 3 }}, /* 65 */ + {.rangeBefore = { 2, 3 }, .spanIndex = 1, .rangeInSpan = { 1, 2 }, .spanRange = { 1, 4 }, .value = u"aAc"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 2, 4 }}, /* 66 */ + {.rangeBefore = { 2, 4 }, .spanIndex = 1, .rangeInSpan = { 1, 2 }, .spanRange = { 1, 3 }, .value = u"aA"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 2, 5 }}, /* 67 */ + {.rangeBefore = { 2, 5 }, .spanIndex = 1, .rangeInSpan = { 1, 2 }, .spanRange = { 1, 3 }, .value = u"aA"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 3, 4 }}, /* 68 */ + {.rangeBefore = { 3, 4 }, .spanIndex = 1, .rangeInSpan = { 2, 3 }, .spanRange = { 1, 4 }, .value = u"abA"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 3, 5 }}, /* 69 */ + {.rangeBefore = { 3, 5 }, .spanIndex = 1, .rangeInSpan = { 2, 3 }, .spanRange = { 1, 4 }, .value = u"abA"}}, + {{ .spans = "[IMAGE]abc[IMAGE]", .selector = { 4, 5 }}, /* 70 */ + {.rangeBefore = { 4, 5 }, .spanIndex = 1, .rangeInSpan = { 3, 4 }, .spanRange = { 1, 5 }, .value = u"abcA"}}, + + {{ .spans = "[IMAGE][IMAGE][IMAGE]", .selector = { 0, 1 }}, /* 71 */ + {.rangeBefore = { 0, 1 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[IMAGE][IMAGE][IMAGE]", .selector = { 1, 2 }}, /* 72 */ + {.rangeBefore = { 1, 2 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[IMAGE][IMAGE][IMAGE]", .selector = { 2, 3 }}, /* 73 */ + {.rangeBefore = { 2, 3 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 2, 3 }, .value = u"A"}}, + + {{ .spans = "[IMAGE][SYMBOL][IMAGE]", .selector = { 0, 1 }}, /* 74 */ + {.rangeBefore = { 0, 1 }, .spanIndex = 0, .rangeInSpan = { 0, 1 }, .spanRange = { 0, 1 }, .value = u"A"}}, + {{ .spans = "[IMAGE][SYMBOL][IMAGE]", .selector = { 1, 3 }}, /* 75 */ + {.rangeBefore = { 1, 3 }, .spanIndex = 1, .rangeInSpan = { 0, 1 }, .spanRange = { 1, 2 }, .value = u"A"}}, + {{ .spans = "[IMAGE][SYMBOL][IMAGE]", .selector = { 3, 4 }}, /* 76 */ + {.rangeBefore = { 3, 4 }, .spanIndex = 2, .rangeInSpan = { 0, 1 }, .spanRange = { 3, 4 }, .value = u"A"}}, +}; + +} // namespace + +class RichEditorOnWillTestReplaceInsert : public RichEditorOnWillTestCommon {}; + +#define CREATE_REPLACE_INSERT_CASE(number) \ + CREATE_INSERT_CASE(RichEditorOnWillTestReplaceInsert, REPLACE_INSERT_CASES, number) + +GENERATE_CASES(77, CREATE_REPLACE_INSERT_CASE); +} \ No newline at end of file diff --git a/test/unittest/core/pattern/rich_editor/rich_editor_recursive_macro.h b/test/unittest/core/pattern/rich_editor/rich_editor_recursive_macro.h new file mode 100644 index 0000000000000000000000000000000000000000..23e38bbd740d15ece3cfeeec32d00bb1b73239e5 --- /dev/null +++ b/test/unittest/core/pattern/rich_editor/rich_editor_recursive_macro.h @@ -0,0 +1,1020 @@ + /* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FOUNDATION_ACE_TEST_UNITTEST_CORE_PATTERN_RICH_EDITOR_RICH_EDITOR_RECURSIVE_MACRO_H +#define FOUNDATION_ACE_TEST_UNITTEST_CORE_PATTERN_RICH_EDITOR_RICH_EDITOR_RECURSIVE_MACRO_H + +#define EXPAND_0(OP, n) +#define EXPAND_1(OP, n) OP(0) +#define EXPAND_2(OP, n) EXPAND_1(OP, n) OP(1) +#define EXPAND_3(OP, n) EXPAND_2(OP, n) OP(2) +#define EXPAND_4(OP, n) EXPAND_3(OP, n) OP(3) +#define EXPAND_5(OP, n) EXPAND_4(OP, n) OP(4) +#define EXPAND_6(OP, n) EXPAND_5(OP, n) OP(5) +#define EXPAND_7(OP, n) EXPAND_6(OP, n) OP(6) +#define EXPAND_8(OP, n) EXPAND_7(OP, n) OP(7) +#define EXPAND_9(OP, n) EXPAND_8(OP, n) OP(8) +#define EXPAND_10(OP, n) EXPAND_9(OP, n) OP(9) +#define EXPAND_11(OP, n) EXPAND_10(OP, n) OP(10) +#define EXPAND_12(OP, n) EXPAND_11(OP, n) OP(11) +#define EXPAND_13(OP, n) EXPAND_12(OP, n) OP(12) +#define EXPAND_14(OP, n) EXPAND_13(OP, n) OP(13) +#define EXPAND_15(OP, n) EXPAND_14(OP, n) OP(14) +#define EXPAND_16(OP, n) EXPAND_15(OP, n) OP(15) +#define EXPAND_17(OP, n) EXPAND_16(OP, n) OP(16) +#define EXPAND_18(OP, n) EXPAND_17(OP, n) OP(17) +#define EXPAND_19(OP, n) EXPAND_18(OP, n) OP(18) +#define EXPAND_20(OP, n) EXPAND_19(OP, n) OP(19) +#define EXPAND_21(OP, n) EXPAND_20(OP, n) OP(20) +#define EXPAND_22(OP, n) EXPAND_21(OP, n) OP(21) +#define EXPAND_23(OP, n) EXPAND_22(OP, n) OP(22) +#define EXPAND_24(OP, n) EXPAND_23(OP, n) OP(23) +#define EXPAND_25(OP, n) EXPAND_24(OP, n) OP(24) +#define EXPAND_26(OP, n) EXPAND_25(OP, n) OP(25) +#define EXPAND_27(OP, n) EXPAND_26(OP, n) OP(26) +#define EXPAND_28(OP, n) EXPAND_27(OP, n) OP(27) +#define EXPAND_29(OP, n) EXPAND_28(OP, n) OP(28) +#define EXPAND_30(OP, n) EXPAND_29(OP, n) OP(29) +#define EXPAND_31(OP, n) EXPAND_30(OP, n) OP(30) +#define EXPAND_32(OP, n) EXPAND_31(OP, n) OP(31) +#define EXPAND_33(OP, n) EXPAND_32(OP, n) OP(32) +#define EXPAND_34(OP, n) EXPAND_33(OP, n) OP(33) +#define EXPAND_35(OP, n) EXPAND_34(OP, n) OP(34) +#define EXPAND_36(OP, n) EXPAND_35(OP, n) OP(35) +#define EXPAND_37(OP, n) EXPAND_36(OP, n) OP(36) +#define EXPAND_38(OP, n) EXPAND_37(OP, n) OP(37) +#define EXPAND_39(OP, n) EXPAND_38(OP, n) OP(38) +#define EXPAND_40(OP, n) EXPAND_39(OP, n) OP(39) +#define EXPAND_41(OP, n) EXPAND_40(OP, n) OP(40) +#define EXPAND_42(OP, n) EXPAND_41(OP, n) OP(41) +#define EXPAND_43(OP, n) EXPAND_42(OP, n) OP(42) +#define EXPAND_44(OP, n) EXPAND_43(OP, n) OP(43) +#define EXPAND_45(OP, n) EXPAND_44(OP, n) OP(44) +#define EXPAND_46(OP, n) EXPAND_45(OP, n) OP(45) +#define EXPAND_47(OP, n) EXPAND_46(OP, n) OP(46) +#define EXPAND_48(OP, n) EXPAND_47(OP, n) OP(47) +#define EXPAND_49(OP, n) EXPAND_48(OP, n) OP(48) +#define EXPAND_50(OP, n) EXPAND_49(OP, n) OP(49) +#define EXPAND_51(OP, n) EXPAND_50(OP, n) OP(50) +#define EXPAND_52(OP, n) EXPAND_51(OP, n) OP(51) +#define EXPAND_53(OP, n) EXPAND_52(OP, n) OP(52) +#define EXPAND_54(OP, n) EXPAND_53(OP, n) OP(53) +#define EXPAND_55(OP, n) EXPAND_54(OP, n) OP(54) +#define EXPAND_56(OP, n) EXPAND_55(OP, n) OP(55) +#define EXPAND_57(OP, n) EXPAND_56(OP, n) OP(56) +#define EXPAND_58(OP, n) EXPAND_57(OP, n) OP(57) +#define EXPAND_59(OP, n) EXPAND_58(OP, n) OP(58) +#define EXPAND_60(OP, n) EXPAND_59(OP, n) OP(59) +#define EXPAND_61(OP, n) EXPAND_60(OP, n) OP(60) +#define EXPAND_62(OP, n) EXPAND_61(OP, n) OP(61) +#define EXPAND_63(OP, n) EXPAND_62(OP, n) OP(62) +#define EXPAND_64(OP, n) EXPAND_63(OP, n) OP(63) +#define EXPAND_65(OP, n) EXPAND_64(OP, n) OP(64) +#define EXPAND_66(OP, n) EXPAND_65(OP, n) OP(65) +#define EXPAND_67(OP, n) EXPAND_66(OP, n) OP(66) +#define EXPAND_68(OP, n) EXPAND_67(OP, n) OP(67) +#define EXPAND_69(OP, n) EXPAND_68(OP, n) OP(68) +#define EXPAND_70(OP, n) EXPAND_69(OP, n) OP(69) +#define EXPAND_71(OP, n) EXPAND_70(OP, n) OP(70) +#define EXPAND_72(OP, n) EXPAND_71(OP, n) OP(71) +#define EXPAND_73(OP, n) EXPAND_72(OP, n) OP(72) +#define EXPAND_74(OP, n) EXPAND_73(OP, n) OP(73) +#define EXPAND_75(OP, n) EXPAND_74(OP, n) OP(74) +#define EXPAND_76(OP, n) EXPAND_75(OP, n) OP(75) +#define EXPAND_77(OP, n) EXPAND_76(OP, n) OP(76) +#define EXPAND_78(OP, n) EXPAND_77(OP, n) OP(77) +#define EXPAND_79(OP, n) EXPAND_78(OP, n) OP(78) +#define EXPAND_80(OP, n) EXPAND_79(OP, n) OP(79) +#define EXPAND_81(OP, n) EXPAND_80(OP, n) OP(80) +#define EXPAND_82(OP, n) EXPAND_81(OP, n) OP(81) +#define EXPAND_83(OP, n) EXPAND_82(OP, n) OP(82) +#define EXPAND_84(OP, n) EXPAND_83(OP, n) OP(83) +#define EXPAND_85(OP, n) EXPAND_84(OP, n) OP(84) +#define EXPAND_86(OP, n) EXPAND_85(OP, n) OP(85) +#define EXPAND_87(OP, n) EXPAND_86(OP, n) OP(86) +#define EXPAND_88(OP, n) EXPAND_87(OP, n) OP(87) +#define EXPAND_89(OP, n) EXPAND_88(OP, n) OP(88) +#define EXPAND_90(OP, n) EXPAND_89(OP, n) OP(89) +#define EXPAND_91(OP, n) EXPAND_90(OP, n) OP(90) +#define EXPAND_92(OP, n) EXPAND_91(OP, n) OP(91) +#define EXPAND_93(OP, n) EXPAND_92(OP, n) OP(92) +#define EXPAND_94(OP, n) EXPAND_93(OP, n) OP(93) +#define EXPAND_95(OP, n) EXPAND_94(OP, n) OP(94) +#define EXPAND_96(OP, n) EXPAND_95(OP, n) OP(95) +#define EXPAND_97(OP, n) EXPAND_96(OP, n) OP(96) +#define EXPAND_98(OP, n) EXPAND_97(OP, n) OP(97) +#define EXPAND_99(OP, n) EXPAND_98(OP, n) OP(98) +#define EXPAND_100(OP, n) EXPAND_99(OP, n) OP(99) +#define EXPAND_101(OP, n) EXPAND_100(OP, n) OP(100) +#define EXPAND_102(OP, n) EXPAND_101(OP, n) OP(101) +#define EXPAND_103(OP, n) EXPAND_102(OP, n) OP(102) +#define EXPAND_104(OP, n) EXPAND_103(OP, n) OP(103) +#define EXPAND_105(OP, n) EXPAND_104(OP, n) OP(104) +#define EXPAND_106(OP, n) EXPAND_105(OP, n) OP(105) +#define EXPAND_107(OP, n) EXPAND_106(OP, n) OP(106) +#define EXPAND_108(OP, n) EXPAND_107(OP, n) OP(107) +#define EXPAND_109(OP, n) EXPAND_108(OP, n) OP(108) +#define EXPAND_110(OP, n) EXPAND_109(OP, n) OP(109) +#define EXPAND_111(OP, n) EXPAND_110(OP, n) OP(110) +#define EXPAND_112(OP, n) EXPAND_111(OP, n) OP(111) +#define EXPAND_113(OP, n) EXPAND_112(OP, n) OP(112) +#define EXPAND_114(OP, n) EXPAND_113(OP, n) OP(113) +#define EXPAND_115(OP, n) EXPAND_114(OP, n) OP(114) +#define EXPAND_116(OP, n) EXPAND_115(OP, n) OP(115) +#define EXPAND_117(OP, n) EXPAND_116(OP, n) OP(116) +#define EXPAND_118(OP, n) EXPAND_117(OP, n) OP(117) +#define EXPAND_119(OP, n) EXPAND_118(OP, n) OP(118) +#define EXPAND_120(OP, n) EXPAND_119(OP, n) OP(119) +#define EXPAND_121(OP, n) EXPAND_120(OP, n) OP(120) +#define EXPAND_122(OP, n) EXPAND_121(OP, n) OP(121) +#define EXPAND_123(OP, n) EXPAND_122(OP, n) OP(122) +#define EXPAND_124(OP, n) EXPAND_123(OP, n) OP(123) +#define EXPAND_125(OP, n) EXPAND_124(OP, n) OP(124) +#define EXPAND_126(OP, n) EXPAND_125(OP, n) OP(125) +#define EXPAND_127(OP, n) EXPAND_126(OP, n) OP(126) +#define EXPAND_128(OP, n) EXPAND_127(OP, n) OP(127) +#define EXPAND_129(OP, n) EXPAND_128(OP, n) OP(128) +#define EXPAND_130(OP, n) EXPAND_129(OP, n) OP(129) +#define EXPAND_131(OP, n) EXPAND_130(OP, n) OP(130) +#define EXPAND_132(OP, n) EXPAND_131(OP, n) OP(131) +#define EXPAND_133(OP, n) EXPAND_132(OP, n) OP(132) +#define EXPAND_134(OP, n) EXPAND_133(OP, n) OP(133) +#define EXPAND_135(OP, n) EXPAND_134(OP, n) OP(134) +#define EXPAND_136(OP, n) EXPAND_135(OP, n) OP(135) +#define EXPAND_137(OP, n) EXPAND_136(OP, n) OP(136) +#define EXPAND_138(OP, n) EXPAND_137(OP, n) OP(137) +#define EXPAND_139(OP, n) EXPAND_138(OP, n) OP(138) +#define EXPAND_140(OP, n) EXPAND_139(OP, n) OP(139) +#define EXPAND_141(OP, n) EXPAND_140(OP, n) OP(140) +#define EXPAND_142(OP, n) EXPAND_141(OP, n) OP(141) +#define EXPAND_143(OP, n) EXPAND_142(OP, n) OP(142) +#define EXPAND_144(OP, n) EXPAND_143(OP, n) OP(143) +#define EXPAND_145(OP, n) EXPAND_144(OP, n) OP(144) +#define EXPAND_146(OP, n) EXPAND_145(OP, n) OP(145) +#define EXPAND_147(OP, n) EXPAND_146(OP, n) OP(146) +#define EXPAND_148(OP, n) EXPAND_147(OP, n) OP(147) +#define EXPAND_149(OP, n) EXPAND_148(OP, n) OP(148) +#define EXPAND_150(OP, n) EXPAND_149(OP, n) OP(149) +#define EXPAND_151(OP, n) EXPAND_150(OP, n) OP(150) +#define EXPAND_152(OP, n) EXPAND_151(OP, n) OP(151) +#define EXPAND_153(OP, n) EXPAND_152(OP, n) OP(152) +#define EXPAND_154(OP, n) EXPAND_153(OP, n) OP(153) +#define EXPAND_155(OP, n) EXPAND_154(OP, n) OP(154) +#define EXPAND_156(OP, n) EXPAND_155(OP, n) OP(155) +#define EXPAND_157(OP, n) EXPAND_156(OP, n) OP(156) +#define EXPAND_158(OP, n) EXPAND_157(OP, n) OP(157) +#define EXPAND_159(OP, n) EXPAND_158(OP, n) OP(158) +#define EXPAND_160(OP, n) EXPAND_159(OP, n) OP(159) +#define EXPAND_161(OP, n) EXPAND_160(OP, n) OP(160) +#define EXPAND_162(OP, n) EXPAND_161(OP, n) OP(161) +#define EXPAND_163(OP, n) EXPAND_162(OP, n) OP(162) +#define EXPAND_164(OP, n) EXPAND_163(OP, n) OP(163) +#define EXPAND_165(OP, n) EXPAND_164(OP, n) OP(164) +#define EXPAND_166(OP, n) EXPAND_165(OP, n) OP(165) +#define EXPAND_167(OP, n) EXPAND_166(OP, n) OP(166) +#define EXPAND_168(OP, n) EXPAND_167(OP, n) OP(167) +#define EXPAND_169(OP, n) EXPAND_168(OP, n) OP(168) +#define EXPAND_170(OP, n) EXPAND_169(OP, n) OP(169) +#define EXPAND_171(OP, n) EXPAND_170(OP, n) OP(170) +#define EXPAND_172(OP, n) EXPAND_171(OP, n) OP(171) +#define EXPAND_173(OP, n) EXPAND_172(OP, n) OP(172) +#define EXPAND_174(OP, n) EXPAND_173(OP, n) OP(173) +#define EXPAND_175(OP, n) EXPAND_174(OP, n) OP(174) +#define EXPAND_176(OP, n) EXPAND_175(OP, n) OP(175) +#define EXPAND_177(OP, n) EXPAND_176(OP, n) OP(176) +#define EXPAND_178(OP, n) EXPAND_177(OP, n) OP(177) +#define EXPAND_179(OP, n) EXPAND_178(OP, n) OP(178) +#define EXPAND_180(OP, n) EXPAND_179(OP, n) OP(179) +#define EXPAND_181(OP, n) EXPAND_180(OP, n) OP(180) +#define EXPAND_182(OP, n) EXPAND_181(OP, n) OP(181) +#define EXPAND_183(OP, n) EXPAND_182(OP, n) OP(182) +#define EXPAND_184(OP, n) EXPAND_183(OP, n) OP(183) +#define EXPAND_185(OP, n) EXPAND_184(OP, n) OP(184) +#define EXPAND_186(OP, n) EXPAND_185(OP, n) OP(185) +#define EXPAND_187(OP, n) EXPAND_186(OP, n) OP(186) +#define EXPAND_188(OP, n) EXPAND_187(OP, n) OP(187) +#define EXPAND_189(OP, n) EXPAND_188(OP, n) OP(188) +#define EXPAND_190(OP, n) EXPAND_189(OP, n) OP(189) +#define EXPAND_191(OP, n) EXPAND_190(OP, n) OP(190) +#define EXPAND_192(OP, n) EXPAND_191(OP, n) OP(191) +#define EXPAND_193(OP, n) EXPAND_192(OP, n) OP(192) +#define EXPAND_194(OP, n) EXPAND_193(OP, n) OP(193) +#define EXPAND_195(OP, n) EXPAND_194(OP, n) OP(194) +#define EXPAND_196(OP, n) EXPAND_195(OP, n) OP(195) +#define EXPAND_197(OP, n) EXPAND_196(OP, n) OP(196) +#define EXPAND_198(OP, n) EXPAND_197(OP, n) OP(197) +#define EXPAND_199(OP, n) EXPAND_198(OP, n) OP(198) +#define EXPAND_200(OP, n) EXPAND_199(OP, n) OP(199) +#define EXPAND_201(OP, n) EXPAND_200(OP, n) OP(200) +#define EXPAND_202(OP, n) EXPAND_201(OP, n) OP(201) +#define EXPAND_203(OP, n) EXPAND_202(OP, n) OP(202) +#define EXPAND_204(OP, n) EXPAND_203(OP, n) OP(203) +#define EXPAND_205(OP, n) EXPAND_204(OP, n) OP(204) +#define EXPAND_206(OP, n) EXPAND_205(OP, n) OP(205) +#define EXPAND_207(OP, n) EXPAND_206(OP, n) OP(206) +#define EXPAND_208(OP, n) EXPAND_207(OP, n) OP(207) +#define EXPAND_209(OP, n) EXPAND_208(OP, n) OP(208) +#define EXPAND_210(OP, n) EXPAND_209(OP, n) OP(209) +#define EXPAND_211(OP, n) EXPAND_210(OP, n) OP(210) +#define EXPAND_212(OP, n) EXPAND_211(OP, n) OP(211) +#define EXPAND_213(OP, n) EXPAND_212(OP, n) OP(212) +#define EXPAND_214(OP, n) EXPAND_213(OP, n) OP(213) +#define EXPAND_215(OP, n) EXPAND_214(OP, n) OP(214) +#define EXPAND_216(OP, n) EXPAND_215(OP, n) OP(215) +#define EXPAND_217(OP, n) EXPAND_216(OP, n) OP(216) +#define EXPAND_218(OP, n) EXPAND_217(OP, n) OP(217) +#define EXPAND_219(OP, n) EXPAND_218(OP, n) OP(218) +#define EXPAND_220(OP, n) EXPAND_219(OP, n) OP(219) +#define EXPAND_221(OP, n) EXPAND_220(OP, n) OP(220) +#define EXPAND_222(OP, n) EXPAND_221(OP, n) OP(221) +#define EXPAND_223(OP, n) EXPAND_222(OP, n) OP(222) +#define EXPAND_224(OP, n) EXPAND_223(OP, n) OP(223) +#define EXPAND_225(OP, n) EXPAND_224(OP, n) OP(224) +#define EXPAND_226(OP, n) EXPAND_225(OP, n) OP(225) +#define EXPAND_227(OP, n) EXPAND_226(OP, n) OP(226) +#define EXPAND_228(OP, n) EXPAND_227(OP, n) OP(227) +#define EXPAND_229(OP, n) EXPAND_228(OP, n) OP(228) +#define EXPAND_230(OP, n) EXPAND_229(OP, n) OP(229) +#define EXPAND_231(OP, n) EXPAND_230(OP, n) OP(230) +#define EXPAND_232(OP, n) EXPAND_231(OP, n) OP(231) +#define EXPAND_233(OP, n) EXPAND_232(OP, n) OP(232) +#define EXPAND_234(OP, n) EXPAND_233(OP, n) OP(233) +#define EXPAND_235(OP, n) EXPAND_234(OP, n) OP(234) +#define EXPAND_236(OP, n) EXPAND_235(OP, n) OP(235) +#define EXPAND_237(OP, n) EXPAND_236(OP, n) OP(236) +#define EXPAND_238(OP, n) EXPAND_237(OP, n) OP(237) +#define EXPAND_239(OP, n) EXPAND_238(OP, n) OP(238) +#define EXPAND_240(OP, n) EXPAND_239(OP, n) OP(239) +#define EXPAND_241(OP, n) EXPAND_240(OP, n) OP(240) +#define EXPAND_242(OP, n) EXPAND_241(OP, n) OP(241) +#define EXPAND_243(OP, n) EXPAND_242(OP, n) OP(242) +#define EXPAND_244(OP, n) EXPAND_243(OP, n) OP(243) +#define EXPAND_245(OP, n) EXPAND_244(OP, n) OP(244) +#define EXPAND_246(OP, n) EXPAND_245(OP, n) OP(245) +#define EXPAND_247(OP, n) EXPAND_246(OP, n) OP(246) +#define EXPAND_248(OP, n) EXPAND_247(OP, n) OP(247) +#define EXPAND_249(OP, n) EXPAND_248(OP, n) OP(248) +#define EXPAND_250(OP, n) EXPAND_249(OP, n) OP(249) +#define EXPAND_251(OP, n) EXPAND_250(OP, n) OP(250) +#define EXPAND_252(OP, n) EXPAND_251(OP, n) OP(251) +#define EXPAND_253(OP, n) EXPAND_252(OP, n) OP(252) +#define EXPAND_254(OP, n) EXPAND_253(OP, n) OP(253) +#define EXPAND_255(OP, n) EXPAND_254(OP, n) OP(254) +#define EXPAND_256(OP, n) EXPAND_255(OP, n) OP(255) +#define EXPAND_257(OP, n) EXPAND_256(OP, n) OP(256) +#define EXPAND_258(OP, n) EXPAND_257(OP, n) OP(257) +#define EXPAND_259(OP, n) EXPAND_258(OP, n) OP(258) +#define EXPAND_260(OP, n) EXPAND_259(OP, n) OP(259) +#define EXPAND_261(OP, n) EXPAND_260(OP, n) OP(260) +#define EXPAND_262(OP, n) EXPAND_261(OP, n) OP(261) +#define EXPAND_263(OP, n) EXPAND_262(OP, n) OP(262) +#define EXPAND_264(OP, n) EXPAND_263(OP, n) OP(263) +#define EXPAND_265(OP, n) EXPAND_264(OP, n) OP(264) +#define EXPAND_266(OP, n) EXPAND_265(OP, n) OP(265) +#define EXPAND_267(OP, n) EXPAND_266(OP, n) OP(266) +#define EXPAND_268(OP, n) EXPAND_267(OP, n) OP(267) +#define EXPAND_269(OP, n) EXPAND_268(OP, n) OP(268) +#define EXPAND_270(OP, n) EXPAND_269(OP, n) OP(269) +#define EXPAND_271(OP, n) EXPAND_270(OP, n) OP(270) +#define EXPAND_272(OP, n) EXPAND_271(OP, n) OP(271) +#define EXPAND_273(OP, n) EXPAND_272(OP, n) OP(272) +#define EXPAND_274(OP, n) EXPAND_273(OP, n) OP(273) +#define EXPAND_275(OP, n) EXPAND_274(OP, n) OP(274) +#define EXPAND_276(OP, n) EXPAND_275(OP, n) OP(275) +#define EXPAND_277(OP, n) EXPAND_276(OP, n) OP(276) +#define EXPAND_278(OP, n) EXPAND_277(OP, n) OP(277) +#define EXPAND_279(OP, n) EXPAND_278(OP, n) OP(278) +#define EXPAND_280(OP, n) EXPAND_279(OP, n) OP(279) +#define EXPAND_281(OP, n) EXPAND_280(OP, n) OP(280) +#define EXPAND_282(OP, n) EXPAND_281(OP, n) OP(281) +#define EXPAND_283(OP, n) EXPAND_282(OP, n) OP(282) +#define EXPAND_284(OP, n) EXPAND_283(OP, n) OP(283) +#define EXPAND_285(OP, n) EXPAND_284(OP, n) OP(284) +#define EXPAND_286(OP, n) EXPAND_285(OP, n) OP(285) +#define EXPAND_287(OP, n) EXPAND_286(OP, n) OP(286) +#define EXPAND_288(OP, n) EXPAND_287(OP, n) OP(287) +#define EXPAND_289(OP, n) EXPAND_288(OP, n) OP(288) +#define EXPAND_290(OP, n) EXPAND_289(OP, n) OP(289) +#define EXPAND_291(OP, n) EXPAND_290(OP, n) OP(290) +#define EXPAND_292(OP, n) EXPAND_291(OP, n) OP(291) +#define EXPAND_293(OP, n) EXPAND_292(OP, n) OP(292) +#define EXPAND_294(OP, n) EXPAND_293(OP, n) OP(293) +#define EXPAND_295(OP, n) EXPAND_294(OP, n) OP(294) +#define EXPAND_296(OP, n) EXPAND_295(OP, n) OP(295) +#define EXPAND_297(OP, n) EXPAND_296(OP, n) OP(296) +#define EXPAND_298(OP, n) EXPAND_297(OP, n) OP(297) +#define EXPAND_299(OP, n) EXPAND_298(OP, n) OP(298) +#define EXPAND_300(OP, n) EXPAND_299(OP, n) OP(299) +#define EXPAND_301(OP, n) EXPAND_300(OP, n) OP(300) +#define EXPAND_302(OP, n) EXPAND_301(OP, n) OP(301) +#define EXPAND_303(OP, n) EXPAND_302(OP, n) OP(302) +#define EXPAND_304(OP, n) EXPAND_303(OP, n) OP(303) +#define EXPAND_305(OP, n) EXPAND_304(OP, n) OP(304) +#define EXPAND_306(OP, n) EXPAND_305(OP, n) OP(305) +#define EXPAND_307(OP, n) EXPAND_306(OP, n) OP(306) +#define EXPAND_308(OP, n) EXPAND_307(OP, n) OP(307) +#define EXPAND_309(OP, n) EXPAND_308(OP, n) OP(308) +#define EXPAND_310(OP, n) EXPAND_309(OP, n) OP(309) +#define EXPAND_311(OP, n) EXPAND_310(OP, n) OP(310) +#define EXPAND_312(OP, n) EXPAND_311(OP, n) OP(311) +#define EXPAND_313(OP, n) EXPAND_312(OP, n) OP(312) +#define EXPAND_314(OP, n) EXPAND_313(OP, n) OP(313) +#define EXPAND_315(OP, n) EXPAND_314(OP, n) OP(314) +#define EXPAND_316(OP, n) EXPAND_315(OP, n) OP(315) +#define EXPAND_317(OP, n) EXPAND_316(OP, n) OP(316) +#define EXPAND_318(OP, n) EXPAND_317(OP, n) OP(317) +#define EXPAND_319(OP, n) EXPAND_318(OP, n) OP(318) +#define EXPAND_320(OP, n) EXPAND_319(OP, n) OP(319) +#define EXPAND_321(OP, n) EXPAND_320(OP, n) OP(320) +#define EXPAND_322(OP, n) EXPAND_321(OP, n) OP(321) +#define EXPAND_323(OP, n) EXPAND_322(OP, n) OP(322) +#define EXPAND_324(OP, n) EXPAND_323(OP, n) OP(323) +#define EXPAND_325(OP, n) EXPAND_324(OP, n) OP(324) +#define EXPAND_326(OP, n) EXPAND_325(OP, n) OP(325) +#define EXPAND_327(OP, n) EXPAND_326(OP, n) OP(326) +#define EXPAND_328(OP, n) EXPAND_327(OP, n) OP(327) +#define EXPAND_329(OP, n) EXPAND_328(OP, n) OP(328) +#define EXPAND_330(OP, n) EXPAND_329(OP, n) OP(329) +#define EXPAND_331(OP, n) EXPAND_330(OP, n) OP(330) +#define EXPAND_332(OP, n) EXPAND_331(OP, n) OP(331) +#define EXPAND_333(OP, n) EXPAND_332(OP, n) OP(332) +#define EXPAND_334(OP, n) EXPAND_333(OP, n) OP(333) +#define EXPAND_335(OP, n) EXPAND_334(OP, n) OP(334) +#define EXPAND_336(OP, n) EXPAND_335(OP, n) OP(335) +#define EXPAND_337(OP, n) EXPAND_336(OP, n) OP(336) +#define EXPAND_338(OP, n) EXPAND_337(OP, n) OP(337) +#define EXPAND_339(OP, n) EXPAND_338(OP, n) OP(338) +#define EXPAND_340(OP, n) EXPAND_339(OP, n) OP(339) +#define EXPAND_341(OP, n) EXPAND_340(OP, n) OP(340) +#define EXPAND_342(OP, n) EXPAND_341(OP, n) OP(341) +#define EXPAND_343(OP, n) EXPAND_342(OP, n) OP(342) +#define EXPAND_344(OP, n) EXPAND_343(OP, n) OP(343) +#define EXPAND_345(OP, n) EXPAND_344(OP, n) OP(344) +#define EXPAND_346(OP, n) EXPAND_345(OP, n) OP(345) +#define EXPAND_347(OP, n) EXPAND_346(OP, n) OP(346) +#define EXPAND_348(OP, n) EXPAND_347(OP, n) OP(347) +#define EXPAND_349(OP, n) EXPAND_348(OP, n) OP(348) +#define EXPAND_350(OP, n) EXPAND_349(OP, n) OP(349) +#define EXPAND_351(OP, n) EXPAND_350(OP, n) OP(350) +#define EXPAND_352(OP, n) EXPAND_351(OP, n) OP(351) +#define EXPAND_353(OP, n) EXPAND_352(OP, n) OP(352) +#define EXPAND_354(OP, n) EXPAND_353(OP, n) OP(353) +#define EXPAND_355(OP, n) EXPAND_354(OP, n) OP(354) +#define EXPAND_356(OP, n) EXPAND_355(OP, n) OP(355) +#define EXPAND_357(OP, n) EXPAND_356(OP, n) OP(356) +#define EXPAND_358(OP, n) EXPAND_357(OP, n) OP(357) +#define EXPAND_359(OP, n) EXPAND_358(OP, n) OP(358) +#define EXPAND_360(OP, n) EXPAND_359(OP, n) OP(359) +#define EXPAND_361(OP, n) EXPAND_360(OP, n) OP(360) +#define EXPAND_362(OP, n) EXPAND_361(OP, n) OP(361) +#define EXPAND_363(OP, n) EXPAND_362(OP, n) OP(362) +#define EXPAND_364(OP, n) EXPAND_363(OP, n) OP(363) +#define EXPAND_365(OP, n) EXPAND_364(OP, n) OP(364) +#define EXPAND_366(OP, n) EXPAND_365(OP, n) OP(365) +#define EXPAND_367(OP, n) EXPAND_366(OP, n) OP(366) +#define EXPAND_368(OP, n) EXPAND_367(OP, n) OP(367) +#define EXPAND_369(OP, n) EXPAND_368(OP, n) OP(368) +#define EXPAND_370(OP, n) EXPAND_369(OP, n) OP(369) +#define EXPAND_371(OP, n) EXPAND_370(OP, n) OP(370) +#define EXPAND_372(OP, n) EXPAND_371(OP, n) OP(371) +#define EXPAND_373(OP, n) EXPAND_372(OP, n) OP(372) +#define EXPAND_374(OP, n) EXPAND_373(OP, n) OP(373) +#define EXPAND_375(OP, n) EXPAND_374(OP, n) OP(374) +#define EXPAND_376(OP, n) EXPAND_375(OP, n) OP(375) +#define EXPAND_377(OP, n) EXPAND_376(OP, n) OP(376) +#define EXPAND_378(OP, n) EXPAND_377(OP, n) OP(377) +#define EXPAND_379(OP, n) EXPAND_378(OP, n) OP(378) +#define EXPAND_380(OP, n) EXPAND_379(OP, n) OP(379) +#define EXPAND_381(OP, n) EXPAND_380(OP, n) OP(380) +#define EXPAND_382(OP, n) EXPAND_381(OP, n) OP(381) +#define EXPAND_383(OP, n) EXPAND_382(OP, n) OP(382) +#define EXPAND_384(OP, n) EXPAND_383(OP, n) OP(383) +#define EXPAND_385(OP, n) EXPAND_384(OP, n) OP(384) +#define EXPAND_386(OP, n) EXPAND_385(OP, n) OP(385) +#define EXPAND_387(OP, n) EXPAND_386(OP, n) OP(386) +#define EXPAND_388(OP, n) EXPAND_387(OP, n) OP(387) +#define EXPAND_389(OP, n) EXPAND_388(OP, n) OP(388) +#define EXPAND_390(OP, n) EXPAND_389(OP, n) OP(389) +#define EXPAND_391(OP, n) EXPAND_390(OP, n) OP(390) +#define EXPAND_392(OP, n) EXPAND_391(OP, n) OP(391) +#define EXPAND_393(OP, n) EXPAND_392(OP, n) OP(392) +#define EXPAND_394(OP, n) EXPAND_393(OP, n) OP(393) +#define EXPAND_395(OP, n) EXPAND_394(OP, n) OP(394) +#define EXPAND_396(OP, n) EXPAND_395(OP, n) OP(395) +#define EXPAND_397(OP, n) EXPAND_396(OP, n) OP(396) +#define EXPAND_398(OP, n) EXPAND_397(OP, n) OP(397) +#define EXPAND_399(OP, n) EXPAND_398(OP, n) OP(398) +#define EXPAND_400(OP, n) EXPAND_399(OP, n) OP(399) +#define EXPAND_401(OP, n) EXPAND_400(OP, n) OP(400) +#define EXPAND_402(OP, n) EXPAND_401(OP, n) OP(401) +#define EXPAND_403(OP, n) EXPAND_402(OP, n) OP(402) +#define EXPAND_404(OP, n) EXPAND_403(OP, n) OP(403) +#define EXPAND_405(OP, n) EXPAND_404(OP, n) OP(404) +#define EXPAND_406(OP, n) EXPAND_405(OP, n) OP(405) +#define EXPAND_407(OP, n) EXPAND_406(OP, n) OP(406) +#define EXPAND_408(OP, n) EXPAND_407(OP, n) OP(407) +#define EXPAND_409(OP, n) EXPAND_408(OP, n) OP(408) +#define EXPAND_410(OP, n) EXPAND_409(OP, n) OP(409) +#define EXPAND_411(OP, n) EXPAND_410(OP, n) OP(410) +#define EXPAND_412(OP, n) EXPAND_411(OP, n) OP(411) +#define EXPAND_413(OP, n) EXPAND_412(OP, n) OP(412) +#define EXPAND_414(OP, n) EXPAND_413(OP, n) OP(413) +#define EXPAND_415(OP, n) EXPAND_414(OP, n) OP(414) +#define EXPAND_416(OP, n) EXPAND_415(OP, n) OP(415) +#define EXPAND_417(OP, n) EXPAND_416(OP, n) OP(416) +#define EXPAND_418(OP, n) EXPAND_417(OP, n) OP(417) +#define EXPAND_419(OP, n) EXPAND_418(OP, n) OP(418) +#define EXPAND_420(OP, n) EXPAND_419(OP, n) OP(419) +#define EXPAND_421(OP, n) EXPAND_420(OP, n) OP(420) +#define EXPAND_422(OP, n) EXPAND_421(OP, n) OP(421) +#define EXPAND_423(OP, n) EXPAND_422(OP, n) OP(422) +#define EXPAND_424(OP, n) EXPAND_423(OP, n) OP(423) +#define EXPAND_425(OP, n) EXPAND_424(OP, n) OP(424) +#define EXPAND_426(OP, n) EXPAND_425(OP, n) OP(425) +#define EXPAND_427(OP, n) EXPAND_426(OP, n) OP(426) +#define EXPAND_428(OP, n) EXPAND_427(OP, n) OP(427) +#define EXPAND_429(OP, n) EXPAND_428(OP, n) OP(428) +#define EXPAND_430(OP, n) EXPAND_429(OP, n) OP(429) +#define EXPAND_431(OP, n) EXPAND_430(OP, n) OP(430) +#define EXPAND_432(OP, n) EXPAND_431(OP, n) OP(431) +#define EXPAND_433(OP, n) EXPAND_432(OP, n) OP(432) +#define EXPAND_434(OP, n) EXPAND_433(OP, n) OP(433) +#define EXPAND_435(OP, n) EXPAND_434(OP, n) OP(434) +#define EXPAND_436(OP, n) EXPAND_435(OP, n) OP(435) +#define EXPAND_437(OP, n) EXPAND_436(OP, n) OP(436) +#define EXPAND_438(OP, n) EXPAND_437(OP, n) OP(437) +#define EXPAND_439(OP, n) EXPAND_438(OP, n) OP(438) +#define EXPAND_440(OP, n) EXPAND_439(OP, n) OP(439) +#define EXPAND_441(OP, n) EXPAND_440(OP, n) OP(440) +#define EXPAND_442(OP, n) EXPAND_441(OP, n) OP(441) +#define EXPAND_443(OP, n) EXPAND_442(OP, n) OP(442) +#define EXPAND_444(OP, n) EXPAND_443(OP, n) OP(443) +#define EXPAND_445(OP, n) EXPAND_444(OP, n) OP(444) +#define EXPAND_446(OP, n) EXPAND_445(OP, n) OP(445) +#define EXPAND_447(OP, n) EXPAND_446(OP, n) OP(446) +#define EXPAND_448(OP, n) EXPAND_447(OP, n) OP(447) +#define EXPAND_449(OP, n) EXPAND_448(OP, n) OP(448) +#define EXPAND_450(OP, n) EXPAND_449(OP, n) OP(449) +#define EXPAND_451(OP, n) EXPAND_450(OP, n) OP(450) +#define EXPAND_452(OP, n) EXPAND_451(OP, n) OP(451) +#define EXPAND_453(OP, n) EXPAND_452(OP, n) OP(452) +#define EXPAND_454(OP, n) EXPAND_453(OP, n) OP(453) +#define EXPAND_455(OP, n) EXPAND_454(OP, n) OP(454) +#define EXPAND_456(OP, n) EXPAND_455(OP, n) OP(455) +#define EXPAND_457(OP, n) EXPAND_456(OP, n) OP(456) +#define EXPAND_458(OP, n) EXPAND_457(OP, n) OP(457) +#define EXPAND_459(OP, n) EXPAND_458(OP, n) OP(458) +#define EXPAND_460(OP, n) EXPAND_459(OP, n) OP(459) +#define EXPAND_461(OP, n) EXPAND_460(OP, n) OP(460) +#define EXPAND_462(OP, n) EXPAND_461(OP, n) OP(461) +#define EXPAND_463(OP, n) EXPAND_462(OP, n) OP(462) +#define EXPAND_464(OP, n) EXPAND_463(OP, n) OP(463) +#define EXPAND_465(OP, n) EXPAND_464(OP, n) OP(464) +#define EXPAND_466(OP, n) EXPAND_465(OP, n) OP(465) +#define EXPAND_467(OP, n) EXPAND_466(OP, n) OP(466) +#define EXPAND_468(OP, n) EXPAND_467(OP, n) OP(467) +#define EXPAND_469(OP, n) EXPAND_468(OP, n) OP(468) +#define EXPAND_470(OP, n) EXPAND_469(OP, n) OP(469) +#define EXPAND_471(OP, n) EXPAND_470(OP, n) OP(470) +#define EXPAND_472(OP, n) EXPAND_471(OP, n) OP(471) +#define EXPAND_473(OP, n) EXPAND_472(OP, n) OP(472) +#define EXPAND_474(OP, n) EXPAND_473(OP, n) OP(473) +#define EXPAND_475(OP, n) EXPAND_474(OP, n) OP(474) +#define EXPAND_476(OP, n) EXPAND_475(OP, n) OP(475) +#define EXPAND_477(OP, n) EXPAND_476(OP, n) OP(476) +#define EXPAND_478(OP, n) EXPAND_477(OP, n) OP(477) +#define EXPAND_479(OP, n) EXPAND_478(OP, n) OP(478) +#define EXPAND_480(OP, n) EXPAND_479(OP, n) OP(479) +#define EXPAND_481(OP, n) EXPAND_480(OP, n) OP(480) +#define EXPAND_482(OP, n) EXPAND_481(OP, n) OP(481) +#define EXPAND_483(OP, n) EXPAND_482(OP, n) OP(482) +#define EXPAND_484(OP, n) EXPAND_483(OP, n) OP(483) +#define EXPAND_485(OP, n) EXPAND_484(OP, n) OP(484) +#define EXPAND_486(OP, n) EXPAND_485(OP, n) OP(485) +#define EXPAND_487(OP, n) EXPAND_486(OP, n) OP(486) +#define EXPAND_488(OP, n) EXPAND_487(OP, n) OP(487) +#define EXPAND_489(OP, n) EXPAND_488(OP, n) OP(488) +#define EXPAND_490(OP, n) EXPAND_489(OP, n) OP(489) +#define EXPAND_491(OP, n) EXPAND_490(OP, n) OP(490) +#define EXPAND_492(OP, n) EXPAND_491(OP, n) OP(491) +#define EXPAND_493(OP, n) EXPAND_492(OP, n) OP(492) +#define EXPAND_494(OP, n) EXPAND_493(OP, n) OP(493) +#define EXPAND_495(OP, n) EXPAND_494(OP, n) OP(494) +#define EXPAND_496(OP, n) EXPAND_495(OP, n) OP(495) +#define EXPAND_497(OP, n) EXPAND_496(OP, n) OP(496) +#define EXPAND_498(OP, n) EXPAND_497(OP, n) OP(497) +#define EXPAND_499(OP, n) EXPAND_498(OP, n) OP(498) +#define EXPAND_500(OP, n) EXPAND_499(OP, n) OP(499) +#define EXPAND_501(OP, n) EXPAND_500(OP, n) OP(500) +#define EXPAND_502(OP, n) EXPAND_501(OP, n) OP(501) +#define EXPAND_503(OP, n) EXPAND_502(OP, n) OP(502) +#define EXPAND_504(OP, n) EXPAND_503(OP, n) OP(503) +#define EXPAND_505(OP, n) EXPAND_504(OP, n) OP(504) +#define EXPAND_506(OP, n) EXPAND_505(OP, n) OP(505) +#define EXPAND_507(OP, n) EXPAND_506(OP, n) OP(506) +#define EXPAND_508(OP, n) EXPAND_507(OP, n) OP(507) +#define EXPAND_509(OP, n) EXPAND_508(OP, n) OP(508) +#define EXPAND_510(OP, n) EXPAND_509(OP, n) OP(509) +#define EXPAND_511(OP, n) EXPAND_510(OP, n) OP(510) +#define EXPAND_512(OP, n) EXPAND_511(OP, n) OP(511) +#define EXPAND_513(OP, n) EXPAND_512(OP, n) OP(512) +#define EXPAND_514(OP, n) EXPAND_513(OP, n) OP(513) +#define EXPAND_515(OP, n) EXPAND_514(OP, n) OP(514) +#define EXPAND_516(OP, n) EXPAND_515(OP, n) OP(515) +#define EXPAND_517(OP, n) EXPAND_516(OP, n) OP(516) +#define EXPAND_518(OP, n) EXPAND_517(OP, n) OP(517) +#define EXPAND_519(OP, n) EXPAND_518(OP, n) OP(518) +#define EXPAND_520(OP, n) EXPAND_519(OP, n) OP(519) +#define EXPAND_521(OP, n) EXPAND_520(OP, n) OP(520) +#define EXPAND_522(OP, n) EXPAND_521(OP, n) OP(521) +#define EXPAND_523(OP, n) EXPAND_522(OP, n) OP(522) +#define EXPAND_524(OP, n) EXPAND_523(OP, n) OP(523) +#define EXPAND_525(OP, n) EXPAND_524(OP, n) OP(524) +#define EXPAND_526(OP, n) EXPAND_525(OP, n) OP(525) +#define EXPAND_527(OP, n) EXPAND_526(OP, n) OP(526) +#define EXPAND_528(OP, n) EXPAND_527(OP, n) OP(527) +#define EXPAND_529(OP, n) EXPAND_528(OP, n) OP(528) +#define EXPAND_530(OP, n) EXPAND_529(OP, n) OP(529) +#define EXPAND_531(OP, n) EXPAND_530(OP, n) OP(530) +#define EXPAND_532(OP, n) EXPAND_531(OP, n) OP(531) +#define EXPAND_533(OP, n) EXPAND_532(OP, n) OP(532) +#define EXPAND_534(OP, n) EXPAND_533(OP, n) OP(533) +#define EXPAND_535(OP, n) EXPAND_534(OP, n) OP(534) +#define EXPAND_536(OP, n) EXPAND_535(OP, n) OP(535) +#define EXPAND_537(OP, n) EXPAND_536(OP, n) OP(536) +#define EXPAND_538(OP, n) EXPAND_537(OP, n) OP(537) +#define EXPAND_539(OP, n) EXPAND_538(OP, n) OP(538) +#define EXPAND_540(OP, n) EXPAND_539(OP, n) OP(539) +#define EXPAND_541(OP, n) EXPAND_540(OP, n) OP(540) +#define EXPAND_542(OP, n) EXPAND_541(OP, n) OP(541) +#define EXPAND_543(OP, n) EXPAND_542(OP, n) OP(542) +#define EXPAND_544(OP, n) EXPAND_543(OP, n) OP(543) +#define EXPAND_545(OP, n) EXPAND_544(OP, n) OP(544) +#define EXPAND_546(OP, n) EXPAND_545(OP, n) OP(545) +#define EXPAND_547(OP, n) EXPAND_546(OP, n) OP(546) +#define EXPAND_548(OP, n) EXPAND_547(OP, n) OP(547) +#define EXPAND_549(OP, n) EXPAND_548(OP, n) OP(548) +#define EXPAND_550(OP, n) EXPAND_549(OP, n) OP(549) +#define EXPAND_551(OP, n) EXPAND_550(OP, n) OP(550) +#define EXPAND_552(OP, n) EXPAND_551(OP, n) OP(551) +#define EXPAND_553(OP, n) EXPAND_552(OP, n) OP(552) +#define EXPAND_554(OP, n) EXPAND_553(OP, n) OP(553) +#define EXPAND_555(OP, n) EXPAND_554(OP, n) OP(554) +#define EXPAND_556(OP, n) EXPAND_555(OP, n) OP(555) +#define EXPAND_557(OP, n) EXPAND_556(OP, n) OP(556) +#define EXPAND_558(OP, n) EXPAND_557(OP, n) OP(557) +#define EXPAND_559(OP, n) EXPAND_558(OP, n) OP(558) +#define EXPAND_560(OP, n) EXPAND_559(OP, n) OP(559) +#define EXPAND_561(OP, n) EXPAND_560(OP, n) OP(560) +#define EXPAND_562(OP, n) EXPAND_561(OP, n) OP(561) +#define EXPAND_563(OP, n) EXPAND_562(OP, n) OP(562) +#define EXPAND_564(OP, n) EXPAND_563(OP, n) OP(563) +#define EXPAND_565(OP, n) EXPAND_564(OP, n) OP(564) +#define EXPAND_566(OP, n) EXPAND_565(OP, n) OP(565) +#define EXPAND_567(OP, n) EXPAND_566(OP, n) OP(566) +#define EXPAND_568(OP, n) EXPAND_567(OP, n) OP(567) +#define EXPAND_569(OP, n) EXPAND_568(OP, n) OP(568) +#define EXPAND_570(OP, n) EXPAND_569(OP, n) OP(569) +#define EXPAND_571(OP, n) EXPAND_570(OP, n) OP(570) +#define EXPAND_572(OP, n) EXPAND_571(OP, n) OP(571) +#define EXPAND_573(OP, n) EXPAND_572(OP, n) OP(572) +#define EXPAND_574(OP, n) EXPAND_573(OP, n) OP(573) +#define EXPAND_575(OP, n) EXPAND_574(OP, n) OP(574) +#define EXPAND_576(OP, n) EXPAND_575(OP, n) OP(575) +#define EXPAND_577(OP, n) EXPAND_576(OP, n) OP(576) +#define EXPAND_578(OP, n) EXPAND_577(OP, n) OP(577) +#define EXPAND_579(OP, n) EXPAND_578(OP, n) OP(578) +#define EXPAND_580(OP, n) EXPAND_579(OP, n) OP(579) +#define EXPAND_581(OP, n) EXPAND_580(OP, n) OP(580) +#define EXPAND_582(OP, n) EXPAND_581(OP, n) OP(581) +#define EXPAND_583(OP, n) EXPAND_582(OP, n) OP(582) +#define EXPAND_584(OP, n) EXPAND_583(OP, n) OP(583) +#define EXPAND_585(OP, n) EXPAND_584(OP, n) OP(584) +#define EXPAND_586(OP, n) EXPAND_585(OP, n) OP(585) +#define EXPAND_587(OP, n) EXPAND_586(OP, n) OP(586) +#define EXPAND_588(OP, n) EXPAND_587(OP, n) OP(587) +#define EXPAND_589(OP, n) EXPAND_588(OP, n) OP(588) +#define EXPAND_590(OP, n) EXPAND_589(OP, n) OP(589) +#define EXPAND_591(OP, n) EXPAND_590(OP, n) OP(590) +#define EXPAND_592(OP, n) EXPAND_591(OP, n) OP(591) +#define EXPAND_593(OP, n) EXPAND_592(OP, n) OP(592) +#define EXPAND_594(OP, n) EXPAND_593(OP, n) OP(593) +#define EXPAND_595(OP, n) EXPAND_594(OP, n) OP(594) +#define EXPAND_596(OP, n) EXPAND_595(OP, n) OP(595) +#define EXPAND_597(OP, n) EXPAND_596(OP, n) OP(596) +#define EXPAND_598(OP, n) EXPAND_597(OP, n) OP(597) +#define EXPAND_599(OP, n) EXPAND_598(OP, n) OP(598) +#define EXPAND_600(OP, n) EXPAND_599(OP, n) OP(599) +#define EXPAND_601(OP, n) EXPAND_600(OP, n) OP(600) +#define EXPAND_602(OP, n) EXPAND_601(OP, n) OP(601) +#define EXPAND_603(OP, n) EXPAND_602(OP, n) OP(602) +#define EXPAND_604(OP, n) EXPAND_603(OP, n) OP(603) +#define EXPAND_605(OP, n) EXPAND_604(OP, n) OP(604) +#define EXPAND_606(OP, n) EXPAND_605(OP, n) OP(605) +#define EXPAND_607(OP, n) EXPAND_606(OP, n) OP(606) +#define EXPAND_608(OP, n) EXPAND_607(OP, n) OP(607) +#define EXPAND_609(OP, n) EXPAND_608(OP, n) OP(608) +#define EXPAND_610(OP, n) EXPAND_609(OP, n) OP(609) +#define EXPAND_611(OP, n) EXPAND_610(OP, n) OP(610) +#define EXPAND_612(OP, n) EXPAND_611(OP, n) OP(611) +#define EXPAND_613(OP, n) EXPAND_612(OP, n) OP(612) +#define EXPAND_614(OP, n) EXPAND_613(OP, n) OP(613) +#define EXPAND_615(OP, n) EXPAND_614(OP, n) OP(614) +#define EXPAND_616(OP, n) EXPAND_615(OP, n) OP(615) +#define EXPAND_617(OP, n) EXPAND_616(OP, n) OP(616) +#define EXPAND_618(OP, n) EXPAND_617(OP, n) OP(617) +#define EXPAND_619(OP, n) EXPAND_618(OP, n) OP(618) +#define EXPAND_620(OP, n) EXPAND_619(OP, n) OP(619) +#define EXPAND_621(OP, n) EXPAND_620(OP, n) OP(620) +#define EXPAND_622(OP, n) EXPAND_621(OP, n) OP(621) +#define EXPAND_623(OP, n) EXPAND_622(OP, n) OP(622) +#define EXPAND_624(OP, n) EXPAND_623(OP, n) OP(623) +#define EXPAND_625(OP, n) EXPAND_624(OP, n) OP(624) +#define EXPAND_626(OP, n) EXPAND_625(OP, n) OP(625) +#define EXPAND_627(OP, n) EXPAND_626(OP, n) OP(626) +#define EXPAND_628(OP, n) EXPAND_627(OP, n) OP(627) +#define EXPAND_629(OP, n) EXPAND_628(OP, n) OP(628) +#define EXPAND_630(OP, n) EXPAND_629(OP, n) OP(629) +#define EXPAND_631(OP, n) EXPAND_630(OP, n) OP(630) +#define EXPAND_632(OP, n) EXPAND_631(OP, n) OP(631) +#define EXPAND_633(OP, n) EXPAND_632(OP, n) OP(632) +#define EXPAND_634(OP, n) EXPAND_633(OP, n) OP(633) +#define EXPAND_635(OP, n) EXPAND_634(OP, n) OP(634) +#define EXPAND_636(OP, n) EXPAND_635(OP, n) OP(635) +#define EXPAND_637(OP, n) EXPAND_636(OP, n) OP(636) +#define EXPAND_638(OP, n) EXPAND_637(OP, n) OP(637) +#define EXPAND_639(OP, n) EXPAND_638(OP, n) OP(638) +#define EXPAND_640(OP, n) EXPAND_639(OP, n) OP(639) +#define EXPAND_641(OP, n) EXPAND_640(OP, n) OP(640) +#define EXPAND_642(OP, n) EXPAND_641(OP, n) OP(641) +#define EXPAND_643(OP, n) EXPAND_642(OP, n) OP(642) +#define EXPAND_644(OP, n) EXPAND_643(OP, n) OP(643) +#define EXPAND_645(OP, n) EXPAND_644(OP, n) OP(644) +#define EXPAND_646(OP, n) EXPAND_645(OP, n) OP(645) +#define EXPAND_647(OP, n) EXPAND_646(OP, n) OP(646) +#define EXPAND_648(OP, n) EXPAND_647(OP, n) OP(647) +#define EXPAND_649(OP, n) EXPAND_648(OP, n) OP(648) +#define EXPAND_650(OP, n) EXPAND_649(OP, n) OP(649) +#define EXPAND_651(OP, n) EXPAND_650(OP, n) OP(650) +#define EXPAND_652(OP, n) EXPAND_651(OP, n) OP(651) +#define EXPAND_653(OP, n) EXPAND_652(OP, n) OP(652) +#define EXPAND_654(OP, n) EXPAND_653(OP, n) OP(653) +#define EXPAND_655(OP, n) EXPAND_654(OP, n) OP(654) +#define EXPAND_656(OP, n) EXPAND_655(OP, n) OP(655) +#define EXPAND_657(OP, n) EXPAND_656(OP, n) OP(656) +#define EXPAND_658(OP, n) EXPAND_657(OP, n) OP(657) +#define EXPAND_659(OP, n) EXPAND_658(OP, n) OP(658) +#define EXPAND_660(OP, n) EXPAND_659(OP, n) OP(659) +#define EXPAND_661(OP, n) EXPAND_660(OP, n) OP(660) +#define EXPAND_662(OP, n) EXPAND_661(OP, n) OP(661) +#define EXPAND_663(OP, n) EXPAND_662(OP, n) OP(662) +#define EXPAND_664(OP, n) EXPAND_663(OP, n) OP(663) +#define EXPAND_665(OP, n) EXPAND_664(OP, n) OP(664) +#define EXPAND_666(OP, n) EXPAND_665(OP, n) OP(665) +#define EXPAND_667(OP, n) EXPAND_666(OP, n) OP(666) +#define EXPAND_668(OP, n) EXPAND_667(OP, n) OP(667) +#define EXPAND_669(OP, n) EXPAND_668(OP, n) OP(668) +#define EXPAND_670(OP, n) EXPAND_669(OP, n) OP(669) +#define EXPAND_671(OP, n) EXPAND_670(OP, n) OP(670) +#define EXPAND_672(OP, n) EXPAND_671(OP, n) OP(671) +#define EXPAND_673(OP, n) EXPAND_672(OP, n) OP(672) +#define EXPAND_674(OP, n) EXPAND_673(OP, n) OP(673) +#define EXPAND_675(OP, n) EXPAND_674(OP, n) OP(674) +#define EXPAND_676(OP, n) EXPAND_675(OP, n) OP(675) +#define EXPAND_677(OP, n) EXPAND_676(OP, n) OP(676) +#define EXPAND_678(OP, n) EXPAND_677(OP, n) OP(677) +#define EXPAND_679(OP, n) EXPAND_678(OP, n) OP(678) +#define EXPAND_680(OP, n) EXPAND_679(OP, n) OP(679) +#define EXPAND_681(OP, n) EXPAND_680(OP, n) OP(680) +#define EXPAND_682(OP, n) EXPAND_681(OP, n) OP(681) +#define EXPAND_683(OP, n) EXPAND_682(OP, n) OP(682) +#define EXPAND_684(OP, n) EXPAND_683(OP, n) OP(683) +#define EXPAND_685(OP, n) EXPAND_684(OP, n) OP(684) +#define EXPAND_686(OP, n) EXPAND_685(OP, n) OP(685) +#define EXPAND_687(OP, n) EXPAND_686(OP, n) OP(686) +#define EXPAND_688(OP, n) EXPAND_687(OP, n) OP(687) +#define EXPAND_689(OP, n) EXPAND_688(OP, n) OP(688) +#define EXPAND_690(OP, n) EXPAND_689(OP, n) OP(689) +#define EXPAND_691(OP, n) EXPAND_690(OP, n) OP(690) +#define EXPAND_692(OP, n) EXPAND_691(OP, n) OP(691) +#define EXPAND_693(OP, n) EXPAND_692(OP, n) OP(692) +#define EXPAND_694(OP, n) EXPAND_693(OP, n) OP(693) +#define EXPAND_695(OP, n) EXPAND_694(OP, n) OP(694) +#define EXPAND_696(OP, n) EXPAND_695(OP, n) OP(695) +#define EXPAND_697(OP, n) EXPAND_696(OP, n) OP(696) +#define EXPAND_698(OP, n) EXPAND_697(OP, n) OP(697) +#define EXPAND_699(OP, n) EXPAND_698(OP, n) OP(698) +#define EXPAND_700(OP, n) EXPAND_699(OP, n) OP(699) +#define EXPAND_701(OP, n) EXPAND_700(OP, n) OP(700) +#define EXPAND_702(OP, n) EXPAND_701(OP, n) OP(701) +#define EXPAND_703(OP, n) EXPAND_702(OP, n) OP(702) +#define EXPAND_704(OP, n) EXPAND_703(OP, n) OP(703) +#define EXPAND_705(OP, n) EXPAND_704(OP, n) OP(704) +#define EXPAND_706(OP, n) EXPAND_705(OP, n) OP(705) +#define EXPAND_707(OP, n) EXPAND_706(OP, n) OP(706) +#define EXPAND_708(OP, n) EXPAND_707(OP, n) OP(707) +#define EXPAND_709(OP, n) EXPAND_708(OP, n) OP(708) +#define EXPAND_710(OP, n) EXPAND_709(OP, n) OP(709) +#define EXPAND_711(OP, n) EXPAND_710(OP, n) OP(710) +#define EXPAND_712(OP, n) EXPAND_711(OP, n) OP(711) +#define EXPAND_713(OP, n) EXPAND_712(OP, n) OP(712) +#define EXPAND_714(OP, n) EXPAND_713(OP, n) OP(713) +#define EXPAND_715(OP, n) EXPAND_714(OP, n) OP(714) +#define EXPAND_716(OP, n) EXPAND_715(OP, n) OP(715) +#define EXPAND_717(OP, n) EXPAND_716(OP, n) OP(716) +#define EXPAND_718(OP, n) EXPAND_717(OP, n) OP(717) +#define EXPAND_719(OP, n) EXPAND_718(OP, n) OP(718) +#define EXPAND_720(OP, n) EXPAND_719(OP, n) OP(719) +#define EXPAND_721(OP, n) EXPAND_720(OP, n) OP(720) +#define EXPAND_722(OP, n) EXPAND_721(OP, n) OP(721) +#define EXPAND_723(OP, n) EXPAND_722(OP, n) OP(722) +#define EXPAND_724(OP, n) EXPAND_723(OP, n) OP(723) +#define EXPAND_725(OP, n) EXPAND_724(OP, n) OP(724) +#define EXPAND_726(OP, n) EXPAND_725(OP, n) OP(725) +#define EXPAND_727(OP, n) EXPAND_726(OP, n) OP(726) +#define EXPAND_728(OP, n) EXPAND_727(OP, n) OP(727) +#define EXPAND_729(OP, n) EXPAND_728(OP, n) OP(728) +#define EXPAND_730(OP, n) EXPAND_729(OP, n) OP(729) +#define EXPAND_731(OP, n) EXPAND_730(OP, n) OP(730) +#define EXPAND_732(OP, n) EXPAND_731(OP, n) OP(731) +#define EXPAND_733(OP, n) EXPAND_732(OP, n) OP(732) +#define EXPAND_734(OP, n) EXPAND_733(OP, n) OP(733) +#define EXPAND_735(OP, n) EXPAND_734(OP, n) OP(734) +#define EXPAND_736(OP, n) EXPAND_735(OP, n) OP(735) +#define EXPAND_737(OP, n) EXPAND_736(OP, n) OP(736) +#define EXPAND_738(OP, n) EXPAND_737(OP, n) OP(737) +#define EXPAND_739(OP, n) EXPAND_738(OP, n) OP(738) +#define EXPAND_740(OP, n) EXPAND_739(OP, n) OP(739) +#define EXPAND_741(OP, n) EXPAND_740(OP, n) OP(740) +#define EXPAND_742(OP, n) EXPAND_741(OP, n) OP(741) +#define EXPAND_743(OP, n) EXPAND_742(OP, n) OP(742) +#define EXPAND_744(OP, n) EXPAND_743(OP, n) OP(743) +#define EXPAND_745(OP, n) EXPAND_744(OP, n) OP(744) +#define EXPAND_746(OP, n) EXPAND_745(OP, n) OP(745) +#define EXPAND_747(OP, n) EXPAND_746(OP, n) OP(746) +#define EXPAND_748(OP, n) EXPAND_747(OP, n) OP(747) +#define EXPAND_749(OP, n) EXPAND_748(OP, n) OP(748) +#define EXPAND_750(OP, n) EXPAND_749(OP, n) OP(749) +#define EXPAND_751(OP, n) EXPAND_750(OP, n) OP(750) +#define EXPAND_752(OP, n) EXPAND_751(OP, n) OP(751) +#define EXPAND_753(OP, n) EXPAND_752(OP, n) OP(752) +#define EXPAND_754(OP, n) EXPAND_753(OP, n) OP(753) +#define EXPAND_755(OP, n) EXPAND_754(OP, n) OP(754) +#define EXPAND_756(OP, n) EXPAND_755(OP, n) OP(755) +#define EXPAND_757(OP, n) EXPAND_756(OP, n) OP(756) +#define EXPAND_758(OP, n) EXPAND_757(OP, n) OP(757) +#define EXPAND_759(OP, n) EXPAND_758(OP, n) OP(758) +#define EXPAND_760(OP, n) EXPAND_759(OP, n) OP(759) +#define EXPAND_761(OP, n) EXPAND_760(OP, n) OP(760) +#define EXPAND_762(OP, n) EXPAND_761(OP, n) OP(761) +#define EXPAND_763(OP, n) EXPAND_762(OP, n) OP(762) +#define EXPAND_764(OP, n) EXPAND_763(OP, n) OP(763) +#define EXPAND_765(OP, n) EXPAND_764(OP, n) OP(764) +#define EXPAND_766(OP, n) EXPAND_765(OP, n) OP(765) +#define EXPAND_767(OP, n) EXPAND_766(OP, n) OP(766) +#define EXPAND_768(OP, n) EXPAND_767(OP, n) OP(767) +#define EXPAND_769(OP, n) EXPAND_768(OP, n) OP(768) +#define EXPAND_770(OP, n) EXPAND_769(OP, n) OP(769) +#define EXPAND_771(OP, n) EXPAND_770(OP, n) OP(770) +#define EXPAND_772(OP, n) EXPAND_771(OP, n) OP(771) +#define EXPAND_773(OP, n) EXPAND_772(OP, n) OP(772) +#define EXPAND_774(OP, n) EXPAND_773(OP, n) OP(773) +#define EXPAND_775(OP, n) EXPAND_774(OP, n) OP(774) +#define EXPAND_776(OP, n) EXPAND_775(OP, n) OP(775) +#define EXPAND_777(OP, n) EXPAND_776(OP, n) OP(776) +#define EXPAND_778(OP, n) EXPAND_777(OP, n) OP(777) +#define EXPAND_779(OP, n) EXPAND_778(OP, n) OP(778) +#define EXPAND_780(OP, n) EXPAND_779(OP, n) OP(779) +#define EXPAND_781(OP, n) EXPAND_780(OP, n) OP(780) +#define EXPAND_782(OP, n) EXPAND_781(OP, n) OP(781) +#define EXPAND_783(OP, n) EXPAND_782(OP, n) OP(782) +#define EXPAND_784(OP, n) EXPAND_783(OP, n) OP(783) +#define EXPAND_785(OP, n) EXPAND_784(OP, n) OP(784) +#define EXPAND_786(OP, n) EXPAND_785(OP, n) OP(785) +#define EXPAND_787(OP, n) EXPAND_786(OP, n) OP(786) +#define EXPAND_788(OP, n) EXPAND_787(OP, n) OP(787) +#define EXPAND_789(OP, n) EXPAND_788(OP, n) OP(788) +#define EXPAND_790(OP, n) EXPAND_789(OP, n) OP(789) +#define EXPAND_791(OP, n) EXPAND_790(OP, n) OP(790) +#define EXPAND_792(OP, n) EXPAND_791(OP, n) OP(791) +#define EXPAND_793(OP, n) EXPAND_792(OP, n) OP(792) +#define EXPAND_794(OP, n) EXPAND_793(OP, n) OP(793) +#define EXPAND_795(OP, n) EXPAND_794(OP, n) OP(794) +#define EXPAND_796(OP, n) EXPAND_795(OP, n) OP(795) +#define EXPAND_797(OP, n) EXPAND_796(OP, n) OP(796) +#define EXPAND_798(OP, n) EXPAND_797(OP, n) OP(797) +#define EXPAND_799(OP, n) EXPAND_798(OP, n) OP(798) +#define EXPAND_800(OP, n) EXPAND_799(OP, n) OP(799) +#define EXPAND_801(OP, n) EXPAND_800(OP, n) OP(800) +#define EXPAND_802(OP, n) EXPAND_801(OP, n) OP(801) +#define EXPAND_803(OP, n) EXPAND_802(OP, n) OP(802) +#define EXPAND_804(OP, n) EXPAND_803(OP, n) OP(803) +#define EXPAND_805(OP, n) EXPAND_804(OP, n) OP(804) +#define EXPAND_806(OP, n) EXPAND_805(OP, n) OP(805) +#define EXPAND_807(OP, n) EXPAND_806(OP, n) OP(806) +#define EXPAND_808(OP, n) EXPAND_807(OP, n) OP(807) +#define EXPAND_809(OP, n) EXPAND_808(OP, n) OP(808) +#define EXPAND_810(OP, n) EXPAND_809(OP, n) OP(809) +#define EXPAND_811(OP, n) EXPAND_810(OP, n) OP(810) +#define EXPAND_812(OP, n) EXPAND_811(OP, n) OP(811) +#define EXPAND_813(OP, n) EXPAND_812(OP, n) OP(812) +#define EXPAND_814(OP, n) EXPAND_813(OP, n) OP(813) +#define EXPAND_815(OP, n) EXPAND_814(OP, n) OP(814) +#define EXPAND_816(OP, n) EXPAND_815(OP, n) OP(815) +#define EXPAND_817(OP, n) EXPAND_816(OP, n) OP(816) +#define EXPAND_818(OP, n) EXPAND_817(OP, n) OP(817) +#define EXPAND_819(OP, n) EXPAND_818(OP, n) OP(818) +#define EXPAND_820(OP, n) EXPAND_819(OP, n) OP(819) +#define EXPAND_821(OP, n) EXPAND_820(OP, n) OP(820) +#define EXPAND_822(OP, n) EXPAND_821(OP, n) OP(821) +#define EXPAND_823(OP, n) EXPAND_822(OP, n) OP(822) +#define EXPAND_824(OP, n) EXPAND_823(OP, n) OP(823) +#define EXPAND_825(OP, n) EXPAND_824(OP, n) OP(824) +#define EXPAND_826(OP, n) EXPAND_825(OP, n) OP(825) +#define EXPAND_827(OP, n) EXPAND_826(OP, n) OP(826) +#define EXPAND_828(OP, n) EXPAND_827(OP, n) OP(827) +#define EXPAND_829(OP, n) EXPAND_828(OP, n) OP(828) +#define EXPAND_830(OP, n) EXPAND_829(OP, n) OP(829) +#define EXPAND_831(OP, n) EXPAND_830(OP, n) OP(830) +#define EXPAND_832(OP, n) EXPAND_831(OP, n) OP(831) +#define EXPAND_833(OP, n) EXPAND_832(OP, n) OP(832) +#define EXPAND_834(OP, n) EXPAND_833(OP, n) OP(833) +#define EXPAND_835(OP, n) EXPAND_834(OP, n) OP(834) +#define EXPAND_836(OP, n) EXPAND_835(OP, n) OP(835) +#define EXPAND_837(OP, n) EXPAND_836(OP, n) OP(836) +#define EXPAND_838(OP, n) EXPAND_837(OP, n) OP(837) +#define EXPAND_839(OP, n) EXPAND_838(OP, n) OP(838) +#define EXPAND_840(OP, n) EXPAND_839(OP, n) OP(839) +#define EXPAND_841(OP, n) EXPAND_840(OP, n) OP(840) +#define EXPAND_842(OP, n) EXPAND_841(OP, n) OP(841) +#define EXPAND_843(OP, n) EXPAND_842(OP, n) OP(842) +#define EXPAND_844(OP, n) EXPAND_843(OP, n) OP(843) +#define EXPAND_845(OP, n) EXPAND_844(OP, n) OP(844) +#define EXPAND_846(OP, n) EXPAND_845(OP, n) OP(845) +#define EXPAND_847(OP, n) EXPAND_846(OP, n) OP(846) +#define EXPAND_848(OP, n) EXPAND_847(OP, n) OP(847) +#define EXPAND_849(OP, n) EXPAND_848(OP, n) OP(848) +#define EXPAND_850(OP, n) EXPAND_849(OP, n) OP(849) +#define EXPAND_851(OP, n) EXPAND_850(OP, n) OP(850) +#define EXPAND_852(OP, n) EXPAND_851(OP, n) OP(851) +#define EXPAND_853(OP, n) EXPAND_852(OP, n) OP(852) +#define EXPAND_854(OP, n) EXPAND_853(OP, n) OP(853) +#define EXPAND_855(OP, n) EXPAND_854(OP, n) OP(854) +#define EXPAND_856(OP, n) EXPAND_855(OP, n) OP(855) +#define EXPAND_857(OP, n) EXPAND_856(OP, n) OP(856) +#define EXPAND_858(OP, n) EXPAND_857(OP, n) OP(857) +#define EXPAND_859(OP, n) EXPAND_858(OP, n) OP(858) +#define EXPAND_860(OP, n) EXPAND_859(OP, n) OP(859) +#define EXPAND_861(OP, n) EXPAND_860(OP, n) OP(860) +#define EXPAND_862(OP, n) EXPAND_861(OP, n) OP(861) +#define EXPAND_863(OP, n) EXPAND_862(OP, n) OP(862) +#define EXPAND_864(OP, n) EXPAND_863(OP, n) OP(863) +#define EXPAND_865(OP, n) EXPAND_864(OP, n) OP(864) +#define EXPAND_866(OP, n) EXPAND_865(OP, n) OP(865) +#define EXPAND_867(OP, n) EXPAND_866(OP, n) OP(866) +#define EXPAND_868(OP, n) EXPAND_867(OP, n) OP(867) +#define EXPAND_869(OP, n) EXPAND_868(OP, n) OP(868) +#define EXPAND_870(OP, n) EXPAND_869(OP, n) OP(869) +#define EXPAND_871(OP, n) EXPAND_870(OP, n) OP(870) +#define EXPAND_872(OP, n) EXPAND_871(OP, n) OP(871) +#define EXPAND_873(OP, n) EXPAND_872(OP, n) OP(872) +#define EXPAND_874(OP, n) EXPAND_873(OP, n) OP(873) +#define EXPAND_875(OP, n) EXPAND_874(OP, n) OP(874) +#define EXPAND_876(OP, n) EXPAND_875(OP, n) OP(875) +#define EXPAND_877(OP, n) EXPAND_876(OP, n) OP(876) +#define EXPAND_878(OP, n) EXPAND_877(OP, n) OP(877) +#define EXPAND_879(OP, n) EXPAND_878(OP, n) OP(878) +#define EXPAND_880(OP, n) EXPAND_879(OP, n) OP(879) +#define EXPAND_881(OP, n) EXPAND_880(OP, n) OP(880) +#define EXPAND_882(OP, n) EXPAND_881(OP, n) OP(881) +#define EXPAND_883(OP, n) EXPAND_882(OP, n) OP(882) +#define EXPAND_884(OP, n) EXPAND_883(OP, n) OP(883) +#define EXPAND_885(OP, n) EXPAND_884(OP, n) OP(884) +#define EXPAND_886(OP, n) EXPAND_885(OP, n) OP(885) +#define EXPAND_887(OP, n) EXPAND_886(OP, n) OP(886) +#define EXPAND_888(OP, n) EXPAND_887(OP, n) OP(887) +#define EXPAND_889(OP, n) EXPAND_888(OP, n) OP(888) +#define EXPAND_890(OP, n) EXPAND_889(OP, n) OP(889) +#define EXPAND_891(OP, n) EXPAND_890(OP, n) OP(890) +#define EXPAND_892(OP, n) EXPAND_891(OP, n) OP(891) +#define EXPAND_893(OP, n) EXPAND_892(OP, n) OP(892) +#define EXPAND_894(OP, n) EXPAND_893(OP, n) OP(893) +#define EXPAND_895(OP, n) EXPAND_894(OP, n) OP(894) +#define EXPAND_896(OP, n) EXPAND_895(OP, n) OP(895) +#define EXPAND_897(OP, n) EXPAND_896(OP, n) OP(896) +#define EXPAND_898(OP, n) EXPAND_897(OP, n) OP(897) +#define EXPAND_899(OP, n) EXPAND_898(OP, n) OP(898) +#define EXPAND_900(OP, n) EXPAND_899(OP, n) OP(899) +#define EXPAND_901(OP, n) EXPAND_900(OP, n) OP(900) +#define EXPAND_902(OP, n) EXPAND_901(OP, n) OP(901) +#define EXPAND_903(OP, n) EXPAND_902(OP, n) OP(902) +#define EXPAND_904(OP, n) EXPAND_903(OP, n) OP(903) +#define EXPAND_905(OP, n) EXPAND_904(OP, n) OP(904) +#define EXPAND_906(OP, n) EXPAND_905(OP, n) OP(905) +#define EXPAND_907(OP, n) EXPAND_906(OP, n) OP(906) +#define EXPAND_908(OP, n) EXPAND_907(OP, n) OP(907) +#define EXPAND_909(OP, n) EXPAND_908(OP, n) OP(908) +#define EXPAND_910(OP, n) EXPAND_909(OP, n) OP(909) +#define EXPAND_911(OP, n) EXPAND_910(OP, n) OP(910) +#define EXPAND_912(OP, n) EXPAND_911(OP, n) OP(911) +#define EXPAND_913(OP, n) EXPAND_912(OP, n) OP(912) +#define EXPAND_914(OP, n) EXPAND_913(OP, n) OP(913) +#define EXPAND_915(OP, n) EXPAND_914(OP, n) OP(914) +#define EXPAND_916(OP, n) EXPAND_915(OP, n) OP(915) +#define EXPAND_917(OP, n) EXPAND_916(OP, n) OP(916) +#define EXPAND_918(OP, n) EXPAND_917(OP, n) OP(917) +#define EXPAND_919(OP, n) EXPAND_918(OP, n) OP(918) +#define EXPAND_920(OP, n) EXPAND_919(OP, n) OP(919) +#define EXPAND_921(OP, n) EXPAND_920(OP, n) OP(920) +#define EXPAND_922(OP, n) EXPAND_921(OP, n) OP(921) +#define EXPAND_923(OP, n) EXPAND_922(OP, n) OP(922) +#define EXPAND_924(OP, n) EXPAND_923(OP, n) OP(923) +#define EXPAND_925(OP, n) EXPAND_924(OP, n) OP(924) +#define EXPAND_926(OP, n) EXPAND_925(OP, n) OP(925) +#define EXPAND_927(OP, n) EXPAND_926(OP, n) OP(926) +#define EXPAND_928(OP, n) EXPAND_927(OP, n) OP(927) +#define EXPAND_929(OP, n) EXPAND_928(OP, n) OP(928) +#define EXPAND_930(OP, n) EXPAND_929(OP, n) OP(929) +#define EXPAND_931(OP, n) EXPAND_930(OP, n) OP(930) +#define EXPAND_932(OP, n) EXPAND_931(OP, n) OP(931) +#define EXPAND_933(OP, n) EXPAND_932(OP, n) OP(932) +#define EXPAND_934(OP, n) EXPAND_933(OP, n) OP(933) +#define EXPAND_935(OP, n) EXPAND_934(OP, n) OP(934) +#define EXPAND_936(OP, n) EXPAND_935(OP, n) OP(935) +#define EXPAND_937(OP, n) EXPAND_936(OP, n) OP(936) +#define EXPAND_938(OP, n) EXPAND_937(OP, n) OP(937) +#define EXPAND_939(OP, n) EXPAND_938(OP, n) OP(938) +#define EXPAND_940(OP, n) EXPAND_939(OP, n) OP(939) +#define EXPAND_941(OP, n) EXPAND_940(OP, n) OP(940) +#define EXPAND_942(OP, n) EXPAND_941(OP, n) OP(941) +#define EXPAND_943(OP, n) EXPAND_942(OP, n) OP(942) +#define EXPAND_944(OP, n) EXPAND_943(OP, n) OP(943) +#define EXPAND_945(OP, n) EXPAND_944(OP, n) OP(944) +#define EXPAND_946(OP, n) EXPAND_945(OP, n) OP(945) +#define EXPAND_947(OP, n) EXPAND_946(OP, n) OP(946) +#define EXPAND_948(OP, n) EXPAND_947(OP, n) OP(947) +#define EXPAND_949(OP, n) EXPAND_948(OP, n) OP(948) +#define EXPAND_950(OP, n) EXPAND_949(OP, n) OP(949) +#define EXPAND_951(OP, n) EXPAND_950(OP, n) OP(950) +#define EXPAND_952(OP, n) EXPAND_951(OP, n) OP(951) +#define EXPAND_953(OP, n) EXPAND_952(OP, n) OP(952) +#define EXPAND_954(OP, n) EXPAND_953(OP, n) OP(953) +#define EXPAND_955(OP, n) EXPAND_954(OP, n) OP(954) +#define EXPAND_956(OP, n) EXPAND_955(OP, n) OP(955) +#define EXPAND_957(OP, n) EXPAND_956(OP, n) OP(956) +#define EXPAND_958(OP, n) EXPAND_957(OP, n) OP(957) +#define EXPAND_959(OP, n) EXPAND_958(OP, n) OP(958) +#define EXPAND_960(OP, n) EXPAND_959(OP, n) OP(959) +#define EXPAND_961(OP, n) EXPAND_960(OP, n) OP(960) +#define EXPAND_962(OP, n) EXPAND_961(OP, n) OP(961) +#define EXPAND_963(OP, n) EXPAND_962(OP, n) OP(962) +#define EXPAND_964(OP, n) EXPAND_963(OP, n) OP(963) +#define EXPAND_965(OP, n) EXPAND_964(OP, n) OP(964) +#define EXPAND_966(OP, n) EXPAND_965(OP, n) OP(965) +#define EXPAND_967(OP, n) EXPAND_966(OP, n) OP(966) +#define EXPAND_968(OP, n) EXPAND_967(OP, n) OP(967) +#define EXPAND_969(OP, n) EXPAND_968(OP, n) OP(968) +#define EXPAND_970(OP, n) EXPAND_969(OP, n) OP(969) +#define EXPAND_971(OP, n) EXPAND_970(OP, n) OP(970) +#define EXPAND_972(OP, n) EXPAND_971(OP, n) OP(971) +#define EXPAND_973(OP, n) EXPAND_972(OP, n) OP(972) +#define EXPAND_974(OP, n) EXPAND_973(OP, n) OP(973) +#define EXPAND_975(OP, n) EXPAND_974(OP, n) OP(974) +#define EXPAND_976(OP, n) EXPAND_975(OP, n) OP(975) +#define EXPAND_977(OP, n) EXPAND_976(OP, n) OP(976) +#define EXPAND_978(OP, n) EXPAND_977(OP, n) OP(977) +#define EXPAND_979(OP, n) EXPAND_978(OP, n) OP(978) +#define EXPAND_980(OP, n) EXPAND_979(OP, n) OP(979) +#define EXPAND_981(OP, n) EXPAND_980(OP, n) OP(980) +#define EXPAND_982(OP, n) EXPAND_981(OP, n) OP(981) +#define EXPAND_983(OP, n) EXPAND_982(OP, n) OP(982) +#define EXPAND_984(OP, n) EXPAND_983(OP, n) OP(983) +#define EXPAND_985(OP, n) EXPAND_984(OP, n) OP(984) +#define EXPAND_986(OP, n) EXPAND_985(OP, n) OP(985) +#define EXPAND_987(OP, n) EXPAND_986(OP, n) OP(986) +#define EXPAND_988(OP, n) EXPAND_987(OP, n) OP(987) +#define EXPAND_989(OP, n) EXPAND_988(OP, n) OP(988) +#define EXPAND_990(OP, n) EXPAND_989(OP, n) OP(989) +#define EXPAND_991(OP, n) EXPAND_990(OP, n) OP(990) +#define EXPAND_992(OP, n) EXPAND_991(OP, n) OP(991) +#define EXPAND_993(OP, n) EXPAND_992(OP, n) OP(992) +#define EXPAND_994(OP, n) EXPAND_993(OP, n) OP(993) +#define EXPAND_995(OP, n) EXPAND_994(OP, n) OP(994) +#define EXPAND_996(OP, n) EXPAND_995(OP, n) OP(995) +#define EXPAND_997(OP, n) EXPAND_996(OP, n) OP(996) +#define EXPAND_998(OP, n) EXPAND_997(OP, n) OP(997) +#define EXPAND_999(OP, n) EXPAND_998(OP, n) OP(998) + +#endif // FOUNDATION_ACE_TEST_UNITTEST_CORE_PATTERN_RICH_EDITOR_RICH_EDITOR_RECURSIVE_MACRO_H \ No newline at end of file