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