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