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