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