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