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