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