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