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