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