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