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