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