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