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