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