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