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