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