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