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