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