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