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