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