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" />
Home > Journals > Articles
FirstPrev12345...NextLast  Go to Page