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