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