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