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