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