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