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