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