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