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