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