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