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